• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1/*! *****************************************************************************
2Copyright (c) Microsoft Corporation. All rights reserved.
3Licensed under the Apache License, Version 2.0 (the "License"); you may not use
4this file except in compliance with the License. You may obtain a copy of the
5License at http://www.apache.org/licenses/LICENSE-2.0
6
7THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
8KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
9WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
10MERCHANTABLITY OR NON-INFRINGEMENT.
11
12See the Apache Version 2.0 License for specific language governing permissions
13and limitations under the License.
14***************************************************************************** */
15
16declare namespace ts {
17    const versionMajorMinor = "4.9";
18    /** The version of the TypeScript compiler release */
19    const version: string;
20    /**
21     * Type of objects whose values are all of the same type.
22     * The `in` and `for-in` operators can *not* be safely used,
23     * since `Object.prototype` may be modified by outside code.
24     */
25    interface MapLike<T> {
26        [index: string]: T;
27    }
28    interface SortedReadonlyArray<T> extends ReadonlyArray<T> {
29        " __sortedArrayBrand": any;
30    }
31    interface SortedArray<T> extends Array<T> {
32        " __sortedArrayBrand": any;
33    }
34    /** Common read methods for ES6 Map/Set. */
35    interface ReadonlyCollection<K> {
36        readonly size: number;
37        has(key: K): boolean;
38        keys(): Iterator<K>;
39    }
40    /** Common write methods for ES6 Map/Set. */
41    interface Collection<K> extends ReadonlyCollection<K> {
42        delete(key: K): boolean;
43        clear(): void;
44    }
45    /** ES6 Map interface, only read methods included. */
46    interface ReadonlyESMap<K, V> extends ReadonlyCollection<K> {
47        get(key: K): V | undefined;
48        values(): Iterator<V>;
49        entries(): Iterator<[K, V]>;
50        forEach(action: (value: V, key: K) => void): void;
51    }
52    /**
53     * ES6 Map interface, only read methods included.
54     */
55    interface ReadonlyMap<T> extends ReadonlyESMap<string, T> {
56    }
57    /** ES6 Map interface. */
58    interface ESMap<K, V> extends ReadonlyESMap<K, V>, Collection<K> {
59        set(key: K, value: V): this;
60    }
61    /**
62     * ES6 Map interface.
63     */
64    interface Map<T> extends ESMap<string, T> {
65    }
66    /** ES6 Set interface, only read methods included. */
67    interface ReadonlySet<T> extends ReadonlyCollection<T> {
68        has(value: T): boolean;
69        values(): Iterator<T>;
70        entries(): Iterator<[T, T]>;
71        forEach(action: (value: T, key: T) => void): void;
72    }
73    /** ES6 Set interface. */
74    interface Set<T> extends ReadonlySet<T>, Collection<T> {
75        add(value: T): this;
76        delete(value: T): boolean;
77    }
78    /** ES6 Iterator type. */
79    interface Iterator<T> {
80        next(): {
81            value: T;
82            done?: false;
83        } | {
84            value: void;
85            done: true;
86        };
87    }
88    /** Array that is only intended to be pushed to, never read. */
89    interface Push<T> {
90        push(...values: T[]): void;
91    }
92}
93declare namespace ts {
94    export type Path = string & {
95        __pathBrand: any;
96    };
97    export interface TextRange {
98        pos: number;
99        end: number;
100    }
101    export interface ReadonlyTextRange {
102        readonly pos: number;
103        readonly end: number;
104    }
105    export enum SyntaxKind {
106        Unknown = 0,
107        EndOfFileToken = 1,
108        SingleLineCommentTrivia = 2,
109        MultiLineCommentTrivia = 3,
110        NewLineTrivia = 4,
111        WhitespaceTrivia = 5,
112        ShebangTrivia = 6,
113        ConflictMarkerTrivia = 7,
114        NumericLiteral = 8,
115        BigIntLiteral = 9,
116        StringLiteral = 10,
117        JsxText = 11,
118        JsxTextAllWhiteSpaces = 12,
119        RegularExpressionLiteral = 13,
120        NoSubstitutionTemplateLiteral = 14,
121        TemplateHead = 15,
122        TemplateMiddle = 16,
123        TemplateTail = 17,
124        OpenBraceToken = 18,
125        CloseBraceToken = 19,
126        OpenParenToken = 20,
127        CloseParenToken = 21,
128        OpenBracketToken = 22,
129        CloseBracketToken = 23,
130        DotToken = 24,
131        DotDotDotToken = 25,
132        SemicolonToken = 26,
133        CommaToken = 27,
134        QuestionDotToken = 28,
135        LessThanToken = 29,
136        LessThanSlashToken = 30,
137        GreaterThanToken = 31,
138        LessThanEqualsToken = 32,
139        GreaterThanEqualsToken = 33,
140        EqualsEqualsToken = 34,
141        ExclamationEqualsToken = 35,
142        EqualsEqualsEqualsToken = 36,
143        ExclamationEqualsEqualsToken = 37,
144        EqualsGreaterThanToken = 38,
145        PlusToken = 39,
146        MinusToken = 40,
147        AsteriskToken = 41,
148        AsteriskAsteriskToken = 42,
149        SlashToken = 43,
150        PercentToken = 44,
151        PlusPlusToken = 45,
152        MinusMinusToken = 46,
153        LessThanLessThanToken = 47,
154        GreaterThanGreaterThanToken = 48,
155        GreaterThanGreaterThanGreaterThanToken = 49,
156        AmpersandToken = 50,
157        BarToken = 51,
158        CaretToken = 52,
159        ExclamationToken = 53,
160        TildeToken = 54,
161        AmpersandAmpersandToken = 55,
162        BarBarToken = 56,
163        QuestionToken = 57,
164        ColonToken = 58,
165        AtToken = 59,
166        QuestionQuestionToken = 60,
167        /** Only the JSDoc scanner produces BacktickToken. The normal scanner produces NoSubstitutionTemplateLiteral and related kinds. */
168        BacktickToken = 61,
169        /** Only the JSDoc scanner produces HashToken. The normal scanner produces PrivateIdentifier. */
170        HashToken = 62,
171        EqualsToken = 63,
172        PlusEqualsToken = 64,
173        MinusEqualsToken = 65,
174        AsteriskEqualsToken = 66,
175        AsteriskAsteriskEqualsToken = 67,
176        SlashEqualsToken = 68,
177        PercentEqualsToken = 69,
178        LessThanLessThanEqualsToken = 70,
179        GreaterThanGreaterThanEqualsToken = 71,
180        GreaterThanGreaterThanGreaterThanEqualsToken = 72,
181        AmpersandEqualsToken = 73,
182        BarEqualsToken = 74,
183        BarBarEqualsToken = 75,
184        AmpersandAmpersandEqualsToken = 76,
185        QuestionQuestionEqualsToken = 77,
186        CaretEqualsToken = 78,
187        Identifier = 79,
188        PrivateIdentifier = 80,
189        BreakKeyword = 81,
190        CaseKeyword = 82,
191        CatchKeyword = 83,
192        ClassKeyword = 84,
193        StructKeyword = 85,
194        ConstKeyword = 86,
195        ContinueKeyword = 87,
196        DebuggerKeyword = 88,
197        DefaultKeyword = 89,
198        DeleteKeyword = 90,
199        DoKeyword = 91,
200        ElseKeyword = 92,
201        EnumKeyword = 93,
202        ExportKeyword = 94,
203        ExtendsKeyword = 95,
204        FalseKeyword = 96,
205        FinallyKeyword = 97,
206        ForKeyword = 98,
207        FunctionKeyword = 99,
208        IfKeyword = 100,
209        ImportKeyword = 101,
210        InKeyword = 102,
211        InstanceOfKeyword = 103,
212        NewKeyword = 104,
213        NullKeyword = 105,
214        ReturnKeyword = 106,
215        SuperKeyword = 107,
216        SwitchKeyword = 108,
217        ThisKeyword = 109,
218        ThrowKeyword = 110,
219        TrueKeyword = 111,
220        TryKeyword = 112,
221        TypeOfKeyword = 113,
222        VarKeyword = 114,
223        VoidKeyword = 115,
224        WhileKeyword = 116,
225        WithKeyword = 117,
226        ImplementsKeyword = 118,
227        InterfaceKeyword = 119,
228        LetKeyword = 120,
229        PackageKeyword = 121,
230        PrivateKeyword = 122,
231        ProtectedKeyword = 123,
232        PublicKeyword = 124,
233        StaticKeyword = 125,
234        YieldKeyword = 126,
235        AbstractKeyword = 127,
236        AccessorKeyword = 128,
237        AsKeyword = 129,
238        AssertsKeyword = 130,
239        AssertKeyword = 131,
240        AnyKeyword = 132,
241        AsyncKeyword = 133,
242        AwaitKeyword = 134,
243        BooleanKeyword = 135,
244        ConstructorKeyword = 136,
245        DeclareKeyword = 137,
246        GetKeyword = 138,
247        InferKeyword = 139,
248        IntrinsicKeyword = 140,
249        IsKeyword = 141,
250        KeyOfKeyword = 142,
251        ModuleKeyword = 143,
252        NamespaceKeyword = 144,
253        NeverKeyword = 145,
254        OutKeyword = 146,
255        ReadonlyKeyword = 147,
256        RequireKeyword = 148,
257        NumberKeyword = 149,
258        ObjectKeyword = 150,
259        SatisfiesKeyword = 151,
260        SetKeyword = 152,
261        StringKeyword = 153,
262        SymbolKeyword = 154,
263        TypeKeyword = 155,
264        UndefinedKeyword = 156,
265        UniqueKeyword = 157,
266        UnknownKeyword = 158,
267        FromKeyword = 159,
268        GlobalKeyword = 160,
269        BigIntKeyword = 161,
270        OverrideKeyword = 162,
271        OfKeyword = 163,
272        QualifiedName = 164,
273        ComputedPropertyName = 165,
274        TypeParameter = 166,
275        Parameter = 167,
276        Decorator = 168,
277        PropertySignature = 169,
278        PropertyDeclaration = 170,
279        MethodSignature = 171,
280        MethodDeclaration = 172,
281        ClassStaticBlockDeclaration = 173,
282        Constructor = 174,
283        GetAccessor = 175,
284        SetAccessor = 176,
285        CallSignature = 177,
286        ConstructSignature = 178,
287        IndexSignature = 179,
288        TypePredicate = 180,
289        TypeReference = 181,
290        FunctionType = 182,
291        ConstructorType = 183,
292        TypeQuery = 184,
293        TypeLiteral = 185,
294        ArrayType = 186,
295        TupleType = 187,
296        OptionalType = 188,
297        RestType = 189,
298        UnionType = 190,
299        IntersectionType = 191,
300        ConditionalType = 192,
301        InferType = 193,
302        ParenthesizedType = 194,
303        ThisType = 195,
304        TypeOperator = 196,
305        IndexedAccessType = 197,
306        MappedType = 198,
307        LiteralType = 199,
308        NamedTupleMember = 200,
309        TemplateLiteralType = 201,
310        TemplateLiteralTypeSpan = 202,
311        ImportType = 203,
312        ObjectBindingPattern = 204,
313        ArrayBindingPattern = 205,
314        BindingElement = 206,
315        ArrayLiteralExpression = 207,
316        ObjectLiteralExpression = 208,
317        PropertyAccessExpression = 209,
318        ElementAccessExpression = 210,
319        CallExpression = 211,
320        NewExpression = 212,
321        TaggedTemplateExpression = 213,
322        TypeAssertionExpression = 214,
323        ParenthesizedExpression = 215,
324        FunctionExpression = 216,
325        ArrowFunction = 217,
326        EtsComponentExpression = 218,
327        DeleteExpression = 219,
328        TypeOfExpression = 220,
329        VoidExpression = 221,
330        AwaitExpression = 222,
331        PrefixUnaryExpression = 223,
332        PostfixUnaryExpression = 224,
333        BinaryExpression = 225,
334        ConditionalExpression = 226,
335        TemplateExpression = 227,
336        YieldExpression = 228,
337        SpreadElement = 229,
338        ClassExpression = 230,
339        OmittedExpression = 231,
340        ExpressionWithTypeArguments = 232,
341        AsExpression = 233,
342        NonNullExpression = 234,
343        MetaProperty = 235,
344        SyntheticExpression = 236,
345        SatisfiesExpression = 237,
346        TemplateSpan = 238,
347        SemicolonClassElement = 239,
348        Block = 240,
349        EmptyStatement = 241,
350        VariableStatement = 242,
351        ExpressionStatement = 243,
352        IfStatement = 244,
353        DoStatement = 245,
354        WhileStatement = 246,
355        ForStatement = 247,
356        ForInStatement = 248,
357        ForOfStatement = 249,
358        ContinueStatement = 250,
359        BreakStatement = 251,
360        ReturnStatement = 252,
361        WithStatement = 253,
362        SwitchStatement = 254,
363        LabeledStatement = 255,
364        ThrowStatement = 256,
365        TryStatement = 257,
366        DebuggerStatement = 258,
367        VariableDeclaration = 259,
368        VariableDeclarationList = 260,
369        FunctionDeclaration = 261,
370        ClassDeclaration = 262,
371        StructDeclaration = 263,
372        InterfaceDeclaration = 264,
373        TypeAliasDeclaration = 265,
374        EnumDeclaration = 266,
375        ModuleDeclaration = 267,
376        ModuleBlock = 268,
377        CaseBlock = 269,
378        NamespaceExportDeclaration = 270,
379        ImportEqualsDeclaration = 271,
380        ImportDeclaration = 272,
381        ImportClause = 273,
382        NamespaceImport = 274,
383        NamedImports = 275,
384        ImportSpecifier = 276,
385        ExportAssignment = 277,
386        ExportDeclaration = 278,
387        NamedExports = 279,
388        NamespaceExport = 280,
389        ExportSpecifier = 281,
390        MissingDeclaration = 282,
391        ExternalModuleReference = 283,
392        JsxElement = 284,
393        JsxSelfClosingElement = 285,
394        JsxOpeningElement = 286,
395        JsxClosingElement = 287,
396        JsxFragment = 288,
397        JsxOpeningFragment = 289,
398        JsxClosingFragment = 290,
399        JsxAttribute = 291,
400        JsxAttributes = 292,
401        JsxSpreadAttribute = 293,
402        JsxExpression = 294,
403        CaseClause = 295,
404        DefaultClause = 296,
405        HeritageClause = 297,
406        CatchClause = 298,
407        AssertClause = 299,
408        AssertEntry = 300,
409        ImportTypeAssertionContainer = 301,
410        PropertyAssignment = 302,
411        ShorthandPropertyAssignment = 303,
412        SpreadAssignment = 304,
413        EnumMember = 305,
414        UnparsedPrologue = 306,
415        UnparsedPrepend = 307,
416        UnparsedText = 308,
417        UnparsedInternalText = 309,
418        UnparsedSyntheticReference = 310,
419        SourceFile = 311,
420        Bundle = 312,
421        UnparsedSource = 313,
422        InputFiles = 314,
423        JSDocTypeExpression = 315,
424        JSDocNameReference = 316,
425        JSDocMemberName = 317,
426        JSDocAllType = 318,
427        JSDocUnknownType = 319,
428        JSDocNullableType = 320,
429        JSDocNonNullableType = 321,
430        JSDocOptionalType = 322,
431        JSDocFunctionType = 323,
432        JSDocVariadicType = 324,
433        JSDocNamepathType = 325,
434        JSDoc = 326,
435        /** @deprecated Use SyntaxKind.JSDoc */
436        JSDocComment = 326,
437        JSDocText = 327,
438        JSDocTypeLiteral = 328,
439        JSDocSignature = 329,
440        JSDocLink = 330,
441        JSDocLinkCode = 331,
442        JSDocLinkPlain = 332,
443        JSDocTag = 333,
444        JSDocAugmentsTag = 334,
445        JSDocImplementsTag = 335,
446        JSDocAuthorTag = 336,
447        JSDocDeprecatedTag = 337,
448        JSDocClassTag = 338,
449        JSDocPublicTag = 339,
450        JSDocPrivateTag = 340,
451        JSDocProtectedTag = 341,
452        JSDocReadonlyTag = 342,
453        JSDocOverrideTag = 343,
454        JSDocCallbackTag = 344,
455        JSDocEnumTag = 345,
456        JSDocParameterTag = 346,
457        JSDocReturnTag = 347,
458        JSDocThisTag = 348,
459        JSDocTypeTag = 349,
460        JSDocTemplateTag = 350,
461        JSDocTypedefTag = 351,
462        JSDocSeeTag = 352,
463        JSDocPropertyTag = 353,
464        SyntaxList = 354,
465        NotEmittedStatement = 355,
466        PartiallyEmittedExpression = 356,
467        CommaListExpression = 357,
468        MergeDeclarationMarker = 358,
469        EndOfDeclarationMarker = 359,
470        SyntheticReferenceExpression = 360,
471        Count = 361,
472        FirstAssignment = 63,
473        LastAssignment = 78,
474        FirstCompoundAssignment = 64,
475        LastCompoundAssignment = 78,
476        FirstReservedWord = 81,
477        LastReservedWord = 117,
478        FirstKeyword = 81,
479        LastKeyword = 163,
480        FirstFutureReservedWord = 118,
481        LastFutureReservedWord = 126,
482        FirstTypeNode = 180,
483        LastTypeNode = 203,
484        FirstPunctuation = 18,
485        LastPunctuation = 78,
486        FirstToken = 0,
487        LastToken = 163,
488        FirstTriviaToken = 2,
489        LastTriviaToken = 7,
490        FirstLiteralToken = 8,
491        LastLiteralToken = 14,
492        FirstTemplateToken = 14,
493        LastTemplateToken = 17,
494        FirstBinaryOperator = 29,
495        LastBinaryOperator = 78,
496        FirstStatement = 242,
497        LastStatement = 258,
498        FirstNode = 164,
499        FirstJSDocNode = 315,
500        LastJSDocNode = 353,
501        FirstJSDocTagNode = 333,
502        LastJSDocTagNode = 353,
503    }
504    export type TriviaSyntaxKind = SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia | SyntaxKind.NewLineTrivia | SyntaxKind.WhitespaceTrivia | SyntaxKind.ShebangTrivia | SyntaxKind.ConflictMarkerTrivia;
505    export type LiteralSyntaxKind = SyntaxKind.NumericLiteral | SyntaxKind.BigIntLiteral | SyntaxKind.StringLiteral | SyntaxKind.JsxText | SyntaxKind.JsxTextAllWhiteSpaces | SyntaxKind.RegularExpressionLiteral | SyntaxKind.NoSubstitutionTemplateLiteral;
506    export type PseudoLiteralSyntaxKind = SyntaxKind.TemplateHead | SyntaxKind.TemplateMiddle | SyntaxKind.TemplateTail;
507    export type PunctuationSyntaxKind = SyntaxKind.OpenBraceToken | SyntaxKind.CloseBraceToken | SyntaxKind.OpenParenToken | SyntaxKind.CloseParenToken | SyntaxKind.OpenBracketToken | SyntaxKind.CloseBracketToken | SyntaxKind.DotToken | SyntaxKind.DotDotDotToken | SyntaxKind.SemicolonToken | SyntaxKind.CommaToken | SyntaxKind.QuestionDotToken | SyntaxKind.LessThanToken | SyntaxKind.LessThanSlashToken | SyntaxKind.GreaterThanToken | SyntaxKind.LessThanEqualsToken | SyntaxKind.GreaterThanEqualsToken | SyntaxKind.EqualsEqualsToken | SyntaxKind.ExclamationEqualsToken | SyntaxKind.EqualsEqualsEqualsToken | SyntaxKind.ExclamationEqualsEqualsToken | SyntaxKind.EqualsGreaterThanToken | SyntaxKind.PlusToken | SyntaxKind.MinusToken | SyntaxKind.AsteriskToken | SyntaxKind.AsteriskAsteriskToken | SyntaxKind.SlashToken | SyntaxKind.PercentToken | SyntaxKind.PlusPlusToken | SyntaxKind.MinusMinusToken | SyntaxKind.LessThanLessThanToken | SyntaxKind.GreaterThanGreaterThanToken | SyntaxKind.GreaterThanGreaterThanGreaterThanToken | SyntaxKind.AmpersandToken | SyntaxKind.BarToken | SyntaxKind.CaretToken | SyntaxKind.ExclamationToken | SyntaxKind.TildeToken | SyntaxKind.AmpersandAmpersandToken | SyntaxKind.BarBarToken | SyntaxKind.QuestionQuestionToken | SyntaxKind.QuestionToken | SyntaxKind.ColonToken | SyntaxKind.AtToken | SyntaxKind.BacktickToken | SyntaxKind.HashToken | SyntaxKind.EqualsToken | SyntaxKind.PlusEqualsToken | SyntaxKind.MinusEqualsToken | SyntaxKind.AsteriskEqualsToken | SyntaxKind.AsteriskAsteriskEqualsToken | SyntaxKind.SlashEqualsToken | SyntaxKind.PercentEqualsToken | SyntaxKind.LessThanLessThanEqualsToken | SyntaxKind.GreaterThanGreaterThanEqualsToken | SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken | SyntaxKind.AmpersandEqualsToken | SyntaxKind.BarEqualsToken | SyntaxKind.CaretEqualsToken;
508    export type KeywordSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AccessorKeyword | SyntaxKind.AnyKeyword | SyntaxKind.AsKeyword | SyntaxKind.AssertsKeyword | SyntaxKind.AssertKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.AwaitKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.BreakKeyword | SyntaxKind.CaseKeyword | SyntaxKind.CatchKeyword | SyntaxKind.ClassKeyword | SyntaxKind.StructKeyword | SyntaxKind.ConstKeyword | SyntaxKind.ConstructorKeyword | SyntaxKind.ContinueKeyword | SyntaxKind.DebuggerKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.DeleteKeyword | SyntaxKind.DoKeyword | SyntaxKind.ElseKeyword | SyntaxKind.EnumKeyword | SyntaxKind.ExportKeyword | SyntaxKind.ExtendsKeyword | SyntaxKind.FalseKeyword | SyntaxKind.FinallyKeyword | SyntaxKind.ForKeyword | SyntaxKind.FromKeyword | SyntaxKind.FunctionKeyword | SyntaxKind.GetKeyword | SyntaxKind.GlobalKeyword | SyntaxKind.IfKeyword | SyntaxKind.ImplementsKeyword | SyntaxKind.ImportKeyword | SyntaxKind.InferKeyword | SyntaxKind.InKeyword | SyntaxKind.InstanceOfKeyword | SyntaxKind.InterfaceKeyword | SyntaxKind.IntrinsicKeyword | SyntaxKind.IsKeyword | SyntaxKind.KeyOfKeyword | SyntaxKind.LetKeyword | SyntaxKind.ModuleKeyword | SyntaxKind.NamespaceKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NewKeyword | SyntaxKind.NullKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.OfKeyword | SyntaxKind.PackageKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.OutKeyword | SyntaxKind.OverrideKeyword | SyntaxKind.RequireKeyword | SyntaxKind.ReturnKeyword | SyntaxKind.SatisfiesKeyword | SyntaxKind.SetKeyword | SyntaxKind.StaticKeyword | SyntaxKind.StringKeyword | SyntaxKind.SuperKeyword | SyntaxKind.SwitchKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.ThisKeyword | SyntaxKind.ThrowKeyword | SyntaxKind.TrueKeyword | SyntaxKind.TryKeyword | SyntaxKind.TypeKeyword | SyntaxKind.TypeOfKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VarKeyword | SyntaxKind.VoidKeyword | SyntaxKind.WhileKeyword | SyntaxKind.WithKeyword | SyntaxKind.YieldKeyword;
509    export type ModifierSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AccessorKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.ConstKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.ExportKeyword | SyntaxKind.InKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.OutKeyword | SyntaxKind.OverrideKeyword | SyntaxKind.StaticKeyword;
510    export type KeywordTypeSyntaxKind = SyntaxKind.AnyKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.IntrinsicKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.StringKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VoidKeyword;
511    export type TokenSyntaxKind = SyntaxKind.Unknown | SyntaxKind.EndOfFileToken | TriviaSyntaxKind | LiteralSyntaxKind | PseudoLiteralSyntaxKind | PunctuationSyntaxKind | SyntaxKind.Identifier | KeywordSyntaxKind;
512    export type JsxTokenSyntaxKind = SyntaxKind.LessThanSlashToken | SyntaxKind.EndOfFileToken | SyntaxKind.ConflictMarkerTrivia | SyntaxKind.JsxText | SyntaxKind.JsxTextAllWhiteSpaces | SyntaxKind.OpenBraceToken | SyntaxKind.LessThanToken;
513    export type JSDocSyntaxKind = SyntaxKind.EndOfFileToken | SyntaxKind.WhitespaceTrivia | SyntaxKind.AtToken | SyntaxKind.NewLineTrivia | SyntaxKind.AsteriskToken | SyntaxKind.OpenBraceToken | SyntaxKind.CloseBraceToken | SyntaxKind.LessThanToken | SyntaxKind.GreaterThanToken | SyntaxKind.OpenBracketToken | SyntaxKind.CloseBracketToken | SyntaxKind.EqualsToken | SyntaxKind.CommaToken | SyntaxKind.DotToken | SyntaxKind.Identifier | SyntaxKind.BacktickToken | SyntaxKind.HashToken | SyntaxKind.Unknown | KeywordSyntaxKind;
514    export enum NodeFlags {
515        None = 0,
516        Let = 1,
517        Const = 2,
518        NestedNamespace = 4,
519        Synthesized = 8,
520        Namespace = 16,
521        OptionalChain = 32,
522        ExportContext = 64,
523        ContainsThis = 128,
524        HasImplicitReturn = 256,
525        HasExplicitReturn = 512,
526        GlobalAugmentation = 1024,
527        HasAsyncFunctions = 2048,
528        DisallowInContext = 4096,
529        YieldContext = 8192,
530        DecoratorContext = 16384,
531        AwaitContext = 32768,
532        DisallowConditionalTypesContext = 65536,
533        ThisNodeHasError = 131072,
534        JavaScriptFile = 262144,
535        ThisNodeOrAnySubNodesHasError = 524288,
536        HasAggregatedChildData = 1048576,
537        JSDoc = 8388608,
538        JsonFile = 67108864,
539        EtsContext = 1073741824,
540        BlockScoped = 3,
541        ReachabilityCheckFlags = 768,
542        ReachabilityAndEmitFlags = 2816,
543        ContextFlags = 1124462592,
544        TypeExcludesFlags = 40960,
545    }
546    export enum EtsFlags {
547        None = 0,
548        StructContext = 2,
549        EtsExtendComponentsContext = 4,
550        EtsStylesComponentsContext = 8,
551        EtsBuildContext = 16,
552        EtsBuilderContext = 32,
553        EtsStateStylesContext = 64,
554        EtsComponentsContext = 128,
555        EtsNewExpressionContext = 256
556    }
557    export enum ModifierFlags {
558        None = 0,
559        Export = 1,
560        Ambient = 2,
561        Public = 4,
562        Private = 8,
563        Protected = 16,
564        Static = 32,
565        Readonly = 64,
566        Accessor = 128,
567        Abstract = 256,
568        Async = 512,
569        Default = 1024,
570        Const = 2048,
571        HasComputedJSDocModifiers = 4096,
572        Deprecated = 8192,
573        Override = 16384,
574        In = 32768,
575        Out = 65536,
576        Decorator = 131072,
577        HasComputedFlags = 536870912,
578        AccessibilityModifier = 28,
579        ParameterPropertyModifier = 16476,
580        NonPublicAccessibilityModifier = 24,
581        TypeScriptModifier = 117086,
582        ExportDefault = 1025,
583        All = 258047,
584        Modifier = 126975
585    }
586    export enum JsxFlags {
587        None = 0,
588        /** An element from a named property of the JSX.IntrinsicElements interface */
589        IntrinsicNamedElement = 1,
590        /** An element inferred from the string index signature of the JSX.IntrinsicElements interface */
591        IntrinsicIndexedElement = 2,
592        IntrinsicElement = 3
593    }
594    export interface Node extends ReadonlyTextRange {
595        readonly kind: SyntaxKind;
596        readonly flags: NodeFlags;
597        readonly parent: Node;
598        symbol: Symbol;
599        locals?: SymbolTable;
600        skipCheck?: boolean;
601    }
602    export interface JSDocContainer {
603    }
604    export type HasJSDoc = ParameterDeclaration | CallSignatureDeclaration | ClassStaticBlockDeclaration | ConstructSignatureDeclaration | MethodSignature | PropertySignature | ArrowFunction | ParenthesizedExpression | SpreadAssignment | ShorthandPropertyAssignment | PropertyAssignment | FunctionExpression | EmptyStatement | DebuggerStatement | Block | VariableStatement | ExpressionStatement | IfStatement | DoStatement | WhileStatement | ForStatement | ForInStatement | ForOfStatement | BreakStatement | ContinueStatement | ReturnStatement | WithStatement | SwitchStatement | LabeledStatement | ThrowStatement | TryStatement | FunctionDeclaration | ConstructorDeclaration | MethodDeclaration | VariableDeclaration | PropertyDeclaration | AccessorDeclaration | ClassLikeDeclaration | InterfaceDeclaration | TypeAliasDeclaration | EnumMember | EnumDeclaration | ModuleDeclaration | ImportEqualsDeclaration | ImportDeclaration | NamespaceExportDeclaration | ExportAssignment | IndexSignatureDeclaration | FunctionTypeNode | ConstructorTypeNode | JSDocFunctionType | ExportDeclaration | NamedTupleMember | ExportSpecifier | CaseClause | EndOfFileToken;
605    export type HasType = SignatureDeclaration | VariableDeclaration | ParameterDeclaration | PropertySignature | PropertyDeclaration | TypePredicateNode | ParenthesizedTypeNode | TypeOperatorNode | MappedTypeNode | AssertionExpression | TypeAliasDeclaration | JSDocTypeExpression | JSDocNonNullableType | JSDocNullableType | JSDocOptionalType | JSDocVariadicType;
606    export type HasTypeArguments = CallExpression | NewExpression | TaggedTemplateExpression | JsxOpeningElement | JsxSelfClosingElement;
607    export type HasInitializer = HasExpressionInitializer | ForStatement | ForInStatement | ForOfStatement | JsxAttribute;
608    export type HasExpressionInitializer = VariableDeclaration | ParameterDeclaration | BindingElement | PropertyDeclaration | PropertyAssignment | EnumMember;
609    export type HasDecorators = ParameterDeclaration | PropertyDeclaration | MethodDeclaration | GetAccessorDeclaration | SetAccessorDeclaration | ClassExpression | ClassDeclaration | StructDeclaration | FunctionDeclaration;
610    export type HasIllegalDecorators = PropertyAssignment | ShorthandPropertyAssignment | FunctionDeclaration | ConstructorDeclaration | IndexSignatureDeclaration | ClassStaticBlockDeclaration | MissingDeclaration | VariableStatement | InterfaceDeclaration | TypeAliasDeclaration | EnumDeclaration | ModuleDeclaration | ImportEqualsDeclaration | ImportDeclaration | NamespaceExportDeclaration | ExportDeclaration | ExportAssignment;
611    export type HasModifiers = TypeParameterDeclaration | ParameterDeclaration | ConstructorTypeNode | PropertySignature | PropertyDeclaration | MethodSignature | MethodDeclaration | ConstructorDeclaration | GetAccessorDeclaration | SetAccessorDeclaration | IndexSignatureDeclaration | FunctionExpression | ArrowFunction | ClassExpression | VariableStatement | FunctionDeclaration | ClassDeclaration | StructDeclaration | InterfaceDeclaration | TypeAliasDeclaration | EnumDeclaration | ModuleDeclaration | ImportEqualsDeclaration | ImportDeclaration | ExportAssignment | ExportDeclaration;
612    export interface NodeArray<T extends Node> extends ReadonlyArray<T>, ReadonlyTextRange {
613        readonly hasTrailingComma: boolean;
614    }
615    export interface Token<TKind extends SyntaxKind> extends Node {
616        readonly kind: TKind;
617    }
618    export type EndOfFileToken = Token<SyntaxKind.EndOfFileToken> & JSDocContainer;
619    export interface PunctuationToken<TKind extends PunctuationSyntaxKind> extends Token<TKind> {
620    }
621    export type DotToken = PunctuationToken<SyntaxKind.DotToken>;
622    export type DotDotDotToken = PunctuationToken<SyntaxKind.DotDotDotToken>;
623    export type QuestionToken = PunctuationToken<SyntaxKind.QuestionToken>;
624    export type ExclamationToken = PunctuationToken<SyntaxKind.ExclamationToken>;
625    export type ColonToken = PunctuationToken<SyntaxKind.ColonToken>;
626    export type EqualsToken = PunctuationToken<SyntaxKind.EqualsToken>;
627    export type AsteriskToken = PunctuationToken<SyntaxKind.AsteriskToken>;
628    export type EqualsGreaterThanToken = PunctuationToken<SyntaxKind.EqualsGreaterThanToken>;
629    export type PlusToken = PunctuationToken<SyntaxKind.PlusToken>;
630    export type MinusToken = PunctuationToken<SyntaxKind.MinusToken>;
631    export type QuestionDotToken = PunctuationToken<SyntaxKind.QuestionDotToken>;
632    export interface KeywordToken<TKind extends KeywordSyntaxKind> extends Token<TKind> {
633    }
634    export type AssertsKeyword = KeywordToken<SyntaxKind.AssertsKeyword>;
635    export type AssertKeyword = KeywordToken<SyntaxKind.AssertKeyword>;
636    export type AwaitKeyword = KeywordToken<SyntaxKind.AwaitKeyword>;
637    /** @deprecated Use `AwaitKeyword` instead. */
638    export type AwaitKeywordToken = AwaitKeyword;
639    /** @deprecated Use `AssertsKeyword` instead. */
640    export type AssertsToken = AssertsKeyword;
641    export interface ModifierToken<TKind extends ModifierSyntaxKind> extends KeywordToken<TKind> {
642    }
643    export type AbstractKeyword = ModifierToken<SyntaxKind.AbstractKeyword>;
644    export type AccessorKeyword = ModifierToken<SyntaxKind.AccessorKeyword>;
645    export type AsyncKeyword = ModifierToken<SyntaxKind.AsyncKeyword>;
646    export type ConstKeyword = ModifierToken<SyntaxKind.ConstKeyword>;
647    export type DeclareKeyword = ModifierToken<SyntaxKind.DeclareKeyword>;
648    export type DefaultKeyword = ModifierToken<SyntaxKind.DefaultKeyword>;
649    export type ExportKeyword = ModifierToken<SyntaxKind.ExportKeyword>;
650    export type InKeyword = ModifierToken<SyntaxKind.InKeyword>;
651    export type PrivateKeyword = ModifierToken<SyntaxKind.PrivateKeyword>;
652    export type ProtectedKeyword = ModifierToken<SyntaxKind.ProtectedKeyword>;
653    export type PublicKeyword = ModifierToken<SyntaxKind.PublicKeyword>;
654    export type ReadonlyKeyword = ModifierToken<SyntaxKind.ReadonlyKeyword>;
655    export type OutKeyword = ModifierToken<SyntaxKind.OutKeyword>;
656    export type OverrideKeyword = ModifierToken<SyntaxKind.OverrideKeyword>;
657    export type StaticKeyword = ModifierToken<SyntaxKind.StaticKeyword>;
658    /** @deprecated Use `ReadonlyKeyword` instead. */
659    export type ReadonlyToken = ReadonlyKeyword;
660    export type Modifier = AbstractKeyword | AccessorKeyword | AsyncKeyword | ConstKeyword | DeclareKeyword | DefaultKeyword | ExportKeyword | InKeyword | PrivateKeyword | ProtectedKeyword | PublicKeyword | OutKeyword | OverrideKeyword | ReadonlyKeyword | StaticKeyword;
661    export type ModifierLike = Modifier | Decorator;
662    export type AccessibilityModifier = PublicKeyword | PrivateKeyword | ProtectedKeyword;
663    export type ParameterPropertyModifier = AccessibilityModifier | ReadonlyKeyword;
664    export type ClassMemberModifier = AccessibilityModifier | ReadonlyKeyword | StaticKeyword | AccessorKeyword;
665    export type ModifiersArray = NodeArray<Modifier>;
666    export enum GeneratedIdentifierFlags {
667        None = 0,
668        ReservedInNestedScopes = 8,
669        Optimistic = 16,
670        FileLevel = 32,
671        AllowNameSubstitution = 64
672    }
673    export interface Identifier extends PrimaryExpression, Declaration {
674        readonly kind: SyntaxKind.Identifier;
675        /**
676         * Prefer to use `id.unescapedText`. (Note: This is available only in services, not internally to the TypeScript compiler.)
677         * Text of identifier, but if the identifier begins with two underscores, this will begin with three.
678         */
679        readonly escapedText: __String;
680        readonly originalKeywordKind?: SyntaxKind;
681        isInJSDocNamespace?: boolean;
682    }
683    export interface TransientIdentifier extends Identifier {
684        resolvedSymbol: Symbol;
685    }
686    export interface QualifiedName extends Node {
687        readonly kind: SyntaxKind.QualifiedName;
688        readonly left: EntityName;
689        readonly right: Identifier;
690    }
691    export type EntityName = Identifier | QualifiedName;
692    export type PropertyName = Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | PrivateIdentifier;
693    export type MemberName = Identifier | PrivateIdentifier;
694    export type DeclarationName = Identifier | PrivateIdentifier | StringLiteralLike | NumericLiteral | ComputedPropertyName | ElementAccessExpression | BindingPattern | EntityNameExpression;
695    export interface Declaration extends Node {
696        _declarationBrand: any;
697    }
698    export interface NamedDeclaration extends Declaration {
699        readonly name?: DeclarationName;
700    }
701    export interface DeclarationStatement extends NamedDeclaration, Statement {
702        readonly name?: Identifier | StringLiteral | NumericLiteral;
703    }
704    export interface ComputedPropertyName extends Node {
705        readonly kind: SyntaxKind.ComputedPropertyName;
706        readonly parent: Declaration;
707        readonly expression: Expression;
708    }
709    export interface PrivateIdentifier extends PrimaryExpression {
710        readonly kind: SyntaxKind.PrivateIdentifier;
711        readonly escapedText: __String;
712    }
713    export interface Decorator extends Node {
714        readonly kind: SyntaxKind.Decorator;
715        readonly parent: NamedDeclaration;
716        readonly expression: LeftHandSideExpression;
717    }
718    export interface TypeParameterDeclaration extends NamedDeclaration {
719        readonly kind: SyntaxKind.TypeParameter;
720        readonly parent: DeclarationWithTypeParameterChildren | InferTypeNode;
721        readonly modifiers?: NodeArray<Modifier>;
722        readonly name: Identifier;
723        /** Note: Consider calling `getEffectiveConstraintOfTypeParameter` */
724        readonly constraint?: TypeNode;
725        readonly default?: TypeNode;
726        expression?: Expression;
727    }
728    export interface SignatureDeclarationBase extends NamedDeclaration, JSDocContainer {
729        readonly kind: SignatureDeclaration["kind"];
730        readonly name?: PropertyName;
731        readonly typeParameters?: NodeArray<TypeParameterDeclaration> | undefined;
732        readonly parameters: NodeArray<ParameterDeclaration>;
733        readonly type?: TypeNode | undefined;
734    }
735    export type SignatureDeclaration = CallSignatureDeclaration | ConstructSignatureDeclaration | MethodSignature | IndexSignatureDeclaration | FunctionTypeNode | ConstructorTypeNode | JSDocFunctionType | FunctionDeclaration | MethodDeclaration | ConstructorDeclaration | AccessorDeclaration | FunctionExpression | ArrowFunction;
736    export interface CallSignatureDeclaration extends SignatureDeclarationBase, TypeElement {
737        readonly kind: SyntaxKind.CallSignature;
738    }
739    export interface ConstructSignatureDeclaration extends SignatureDeclarationBase, TypeElement {
740        readonly kind: SyntaxKind.ConstructSignature;
741    }
742    export type BindingName = Identifier | BindingPattern;
743    export interface VariableDeclaration extends NamedDeclaration, JSDocContainer {
744        readonly kind: SyntaxKind.VariableDeclaration;
745        readonly parent: VariableDeclarationList | CatchClause;
746        readonly name: BindingName;
747        readonly exclamationToken?: ExclamationToken;
748        readonly type?: TypeNode;
749        readonly initializer?: Expression;
750    }
751    export interface VariableDeclarationList extends Node {
752        readonly kind: SyntaxKind.VariableDeclarationList;
753        readonly parent: VariableStatement | ForStatement | ForOfStatement | ForInStatement;
754        readonly declarations: NodeArray<VariableDeclaration>;
755    }
756    export interface ParameterDeclaration extends NamedDeclaration, JSDocContainer {
757        readonly kind: SyntaxKind.Parameter;
758        readonly parent: SignatureDeclaration;
759        readonly modifiers?: NodeArray<ModifierLike>;
760        readonly dotDotDotToken?: DotDotDotToken;
761        readonly name: BindingName;
762        readonly questionToken?: QuestionToken;
763        readonly type?: TypeNode;
764        readonly initializer?: Expression;
765    }
766    export interface BindingElement extends NamedDeclaration {
767        readonly kind: SyntaxKind.BindingElement;
768        readonly parent: BindingPattern;
769        readonly propertyName?: PropertyName;
770        readonly dotDotDotToken?: DotDotDotToken;
771        readonly name: BindingName;
772        readonly initializer?: Expression;
773    }
774    export interface PropertySignature extends TypeElement, JSDocContainer {
775        readonly kind: SyntaxKind.PropertySignature;
776        readonly modifiers?: NodeArray<Modifier>;
777        readonly name: PropertyName;
778        readonly questionToken?: QuestionToken;
779        readonly type?: TypeNode;
780    }
781    export interface PropertyDeclaration extends ClassElement, JSDocContainer {
782        readonly kind: SyntaxKind.PropertyDeclaration;
783        readonly parent: ClassLikeDeclaration;
784        readonly modifiers?: NodeArray<ModifierLike>;
785        readonly name: PropertyName;
786        readonly questionToken?: QuestionToken;
787        readonly exclamationToken?: ExclamationToken;
788        readonly type?: TypeNode;
789        readonly initializer?: Expression;
790    }
791    export interface AutoAccessorPropertyDeclaration extends PropertyDeclaration {
792        _autoAccessorBrand: any;
793    }
794    export interface ObjectLiteralElement extends NamedDeclaration {
795        _objectLiteralBrand: any;
796        readonly name?: PropertyName;
797    }
798    /** Unlike ObjectLiteralElement, excludes JSXAttribute and JSXSpreadAttribute. */
799    export type ObjectLiteralElementLike = PropertyAssignment | ShorthandPropertyAssignment | SpreadAssignment | MethodDeclaration | AccessorDeclaration;
800    export interface PropertyAssignment extends ObjectLiteralElement, JSDocContainer {
801        readonly kind: SyntaxKind.PropertyAssignment;
802        readonly parent: ObjectLiteralExpression;
803        readonly name: PropertyName;
804        readonly initializer: Expression;
805    }
806    export interface ShorthandPropertyAssignment extends ObjectLiteralElement, JSDocContainer {
807        readonly kind: SyntaxKind.ShorthandPropertyAssignment;
808        readonly parent: ObjectLiteralExpression;
809        readonly name: Identifier;
810        readonly equalsToken?: EqualsToken;
811        readonly objectAssignmentInitializer?: Expression;
812    }
813    export interface SpreadAssignment extends ObjectLiteralElement, JSDocContainer {
814        readonly kind: SyntaxKind.SpreadAssignment;
815        readonly parent: ObjectLiteralExpression;
816        readonly expression: Expression;
817    }
818    export type VariableLikeDeclaration = VariableDeclaration | ParameterDeclaration | BindingElement | PropertyDeclaration | PropertyAssignment | PropertySignature | JsxAttribute | ShorthandPropertyAssignment | EnumMember | JSDocPropertyTag | JSDocParameterTag;
819    export interface PropertyLikeDeclaration extends NamedDeclaration {
820        readonly name: PropertyName;
821    }
822    export interface ObjectBindingPattern extends Node {
823        readonly kind: SyntaxKind.ObjectBindingPattern;
824        readonly parent: VariableDeclaration | ParameterDeclaration | BindingElement;
825        readonly elements: NodeArray<BindingElement>;
826    }
827    export interface ArrayBindingPattern extends Node {
828        readonly kind: SyntaxKind.ArrayBindingPattern;
829        readonly parent: VariableDeclaration | ParameterDeclaration | BindingElement;
830        readonly elements: NodeArray<ArrayBindingElement>;
831    }
832    export type BindingPattern = ObjectBindingPattern | ArrayBindingPattern;
833    export type ArrayBindingElement = BindingElement | OmittedExpression;
834    /**
835     * Several node kinds share function-like features such as a signature,
836     * a name, and a body. These nodes should extend FunctionLikeDeclarationBase.
837     * Examples:
838     * - FunctionDeclaration
839     * - MethodDeclaration
840     * - AccessorDeclaration
841     */
842    export interface FunctionLikeDeclarationBase extends SignatureDeclarationBase {
843        _functionLikeDeclarationBrand: any;
844        readonly asteriskToken?: AsteriskToken | undefined;
845        readonly questionToken?: QuestionToken | undefined;
846        readonly exclamationToken?: ExclamationToken | undefined;
847        readonly body?: Block | Expression | undefined;
848    }
849    export type FunctionLikeDeclaration = FunctionDeclaration | MethodDeclaration | GetAccessorDeclaration | SetAccessorDeclaration | ConstructorDeclaration | FunctionExpression | ArrowFunction;
850    /** @deprecated Use SignatureDeclaration */
851    export type FunctionLike = SignatureDeclaration;
852    export interface FunctionDeclaration extends FunctionLikeDeclarationBase, DeclarationStatement {
853        readonly kind: SyntaxKind.FunctionDeclaration;
854        readonly modifiers?: NodeArray<Modifier>;
855        readonly name?: Identifier;
856        readonly body?: FunctionBody;
857    }
858    export interface MethodSignature extends SignatureDeclarationBase, TypeElement {
859        readonly kind: SyntaxKind.MethodSignature;
860        readonly parent: ObjectTypeDeclaration;
861        readonly modifiers?: NodeArray<Modifier>;
862        readonly name: PropertyName;
863    }
864    export interface MethodDeclaration extends FunctionLikeDeclarationBase, ClassElement, ObjectLiteralElement, JSDocContainer {
865        readonly kind: SyntaxKind.MethodDeclaration;
866        readonly parent: ClassLikeDeclaration | ObjectLiteralExpression;
867        readonly modifiers?: NodeArray<ModifierLike> | undefined;
868        readonly name: PropertyName;
869        readonly body?: FunctionBody | undefined;
870    }
871    export interface ConstructorDeclaration extends FunctionLikeDeclarationBase, ClassElement, JSDocContainer {
872        readonly kind: SyntaxKind.Constructor;
873        readonly parent: ClassLikeDeclaration;
874        readonly modifiers?: NodeArray<Modifier> | undefined;
875        readonly body?: FunctionBody | undefined;
876    }
877    /** For when we encounter a semicolon in a class declaration. ES6 allows these as class elements. */
878    export interface SemicolonClassElement extends ClassElement {
879        readonly kind: SyntaxKind.SemicolonClassElement;
880        readonly parent: ClassLikeDeclaration;
881    }
882    export interface GetAccessorDeclaration extends FunctionLikeDeclarationBase, ClassElement, TypeElement, ObjectLiteralElement, JSDocContainer {
883        readonly kind: SyntaxKind.GetAccessor;
884        readonly parent: ClassLikeDeclaration | ObjectLiteralExpression | TypeLiteralNode | InterfaceDeclaration;
885        readonly modifiers?: NodeArray<ModifierLike>;
886        readonly name: PropertyName;
887        readonly body?: FunctionBody;
888    }
889    export interface SetAccessorDeclaration extends FunctionLikeDeclarationBase, ClassElement, TypeElement, ObjectLiteralElement, JSDocContainer {
890        readonly kind: SyntaxKind.SetAccessor;
891        readonly parent: ClassLikeDeclaration | ObjectLiteralExpression | TypeLiteralNode | InterfaceDeclaration;
892        readonly modifiers?: NodeArray<ModifierLike>;
893        readonly name: PropertyName;
894        readonly body?: FunctionBody;
895    }
896    export type AccessorDeclaration = GetAccessorDeclaration | SetAccessorDeclaration;
897    export interface IndexSignatureDeclaration extends SignatureDeclarationBase, ClassElement, TypeElement {
898        readonly kind: SyntaxKind.IndexSignature;
899        readonly parent: ObjectTypeDeclaration;
900        readonly modifiers?: NodeArray<Modifier>;
901        readonly type: TypeNode;
902    }
903    export interface ClassStaticBlockDeclaration extends ClassElement, JSDocContainer {
904        readonly kind: SyntaxKind.ClassStaticBlockDeclaration;
905        readonly parent: ClassDeclaration | ClassExpression;
906        readonly body: Block;
907    }
908    export interface TypeNode extends Node {
909        _typeNodeBrand: any;
910    }
911    export interface KeywordTypeNode<TKind extends KeywordTypeSyntaxKind = KeywordTypeSyntaxKind> extends KeywordToken<TKind>, TypeNode {
912        readonly kind: TKind;
913    }
914    export interface ImportTypeAssertionContainer extends Node {
915        readonly kind: SyntaxKind.ImportTypeAssertionContainer;
916        readonly parent: ImportTypeNode;
917        readonly assertClause: AssertClause;
918        readonly multiLine?: boolean;
919    }
920    export interface ImportTypeNode extends NodeWithTypeArguments {
921        readonly kind: SyntaxKind.ImportType;
922        readonly isTypeOf: boolean;
923        readonly argument: TypeNode;
924        readonly assertions?: ImportTypeAssertionContainer;
925        readonly qualifier?: EntityName;
926    }
927    export interface ThisTypeNode extends TypeNode {
928        readonly kind: SyntaxKind.ThisType;
929    }
930    export type FunctionOrConstructorTypeNode = FunctionTypeNode | ConstructorTypeNode;
931    export interface FunctionOrConstructorTypeNodeBase extends TypeNode, SignatureDeclarationBase {
932        readonly kind: SyntaxKind.FunctionType | SyntaxKind.ConstructorType;
933        readonly type: TypeNode;
934    }
935    export interface FunctionTypeNode extends FunctionOrConstructorTypeNodeBase {
936        readonly kind: SyntaxKind.FunctionType;
937    }
938    export interface ConstructorTypeNode extends FunctionOrConstructorTypeNodeBase {
939        readonly kind: SyntaxKind.ConstructorType;
940        readonly modifiers?: NodeArray<Modifier>;
941    }
942    export interface NodeWithTypeArguments extends TypeNode {
943        readonly typeArguments?: NodeArray<TypeNode>;
944    }
945    export type TypeReferenceType = TypeReferenceNode | ExpressionWithTypeArguments;
946    export interface TypeReferenceNode extends NodeWithTypeArguments {
947        readonly kind: SyntaxKind.TypeReference;
948        readonly typeName: EntityName;
949    }
950    export interface TypePredicateNode extends TypeNode {
951        readonly kind: SyntaxKind.TypePredicate;
952        readonly parent: SignatureDeclaration | JSDocTypeExpression;
953        readonly assertsModifier?: AssertsKeyword;
954        readonly parameterName: Identifier | ThisTypeNode;
955        readonly type?: TypeNode;
956    }
957    export interface TypeQueryNode extends NodeWithTypeArguments {
958        readonly kind: SyntaxKind.TypeQuery;
959        readonly exprName: EntityName;
960    }
961    export interface TypeLiteralNode extends TypeNode, Declaration {
962        readonly kind: SyntaxKind.TypeLiteral;
963        readonly members: NodeArray<TypeElement>;
964    }
965    export interface ArrayTypeNode extends TypeNode {
966        readonly kind: SyntaxKind.ArrayType;
967        readonly elementType: TypeNode;
968    }
969    export interface TupleTypeNode extends TypeNode {
970        readonly kind: SyntaxKind.TupleType;
971        readonly elements: NodeArray<TypeNode | NamedTupleMember>;
972    }
973    export interface NamedTupleMember extends TypeNode, JSDocContainer, Declaration {
974        readonly kind: SyntaxKind.NamedTupleMember;
975        readonly dotDotDotToken?: Token<SyntaxKind.DotDotDotToken>;
976        readonly name: Identifier;
977        readonly questionToken?: Token<SyntaxKind.QuestionToken>;
978        readonly type: TypeNode;
979    }
980    export interface OptionalTypeNode extends TypeNode {
981        readonly kind: SyntaxKind.OptionalType;
982        readonly type: TypeNode;
983    }
984    export interface RestTypeNode extends TypeNode {
985        readonly kind: SyntaxKind.RestType;
986        readonly type: TypeNode;
987    }
988    export type UnionOrIntersectionTypeNode = UnionTypeNode | IntersectionTypeNode;
989    export interface UnionTypeNode extends TypeNode {
990        readonly kind: SyntaxKind.UnionType;
991        readonly types: NodeArray<TypeNode>;
992    }
993    export interface IntersectionTypeNode extends TypeNode {
994        readonly kind: SyntaxKind.IntersectionType;
995        readonly types: NodeArray<TypeNode>;
996    }
997    export interface ConditionalTypeNode extends TypeNode {
998        readonly kind: SyntaxKind.ConditionalType;
999        readonly checkType: TypeNode;
1000        readonly extendsType: TypeNode;
1001        readonly trueType: TypeNode;
1002        readonly falseType: TypeNode;
1003    }
1004    export interface InferTypeNode extends TypeNode {
1005        readonly kind: SyntaxKind.InferType;
1006        readonly typeParameter: TypeParameterDeclaration;
1007    }
1008    export interface ParenthesizedTypeNode extends TypeNode {
1009        readonly kind: SyntaxKind.ParenthesizedType;
1010        readonly type: TypeNode;
1011    }
1012    export interface TypeOperatorNode extends TypeNode {
1013        readonly kind: SyntaxKind.TypeOperator;
1014        readonly operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword;
1015        readonly type: TypeNode;
1016    }
1017    export interface IndexedAccessTypeNode extends TypeNode {
1018        readonly kind: SyntaxKind.IndexedAccessType;
1019        readonly objectType: TypeNode;
1020        readonly indexType: TypeNode;
1021    }
1022    export interface MappedTypeNode extends TypeNode, Declaration {
1023        readonly kind: SyntaxKind.MappedType;
1024        readonly readonlyToken?: ReadonlyKeyword | PlusToken | MinusToken;
1025        readonly typeParameter: TypeParameterDeclaration;
1026        readonly nameType?: TypeNode;
1027        readonly questionToken?: QuestionToken | PlusToken | MinusToken;
1028        readonly type?: TypeNode;
1029        /** Used only to produce grammar errors */
1030        readonly members?: NodeArray<TypeElement>;
1031    }
1032    export interface LiteralTypeNode extends TypeNode {
1033        readonly kind: SyntaxKind.LiteralType;
1034        readonly literal: NullLiteral | BooleanLiteral | LiteralExpression | PrefixUnaryExpression;
1035    }
1036    export interface StringLiteral extends LiteralExpression, Declaration {
1037        readonly kind: SyntaxKind.StringLiteral;
1038    }
1039    export type StringLiteralLike = StringLiteral | NoSubstitutionTemplateLiteral;
1040    export type PropertyNameLiteral = Identifier | StringLiteralLike | NumericLiteral;
1041    export interface TemplateLiteralTypeNode extends TypeNode {
1042        kind: SyntaxKind.TemplateLiteralType;
1043        readonly head: TemplateHead;
1044        readonly templateSpans: NodeArray<TemplateLiteralTypeSpan>;
1045    }
1046    export interface TemplateLiteralTypeSpan extends TypeNode {
1047        readonly kind: SyntaxKind.TemplateLiteralTypeSpan;
1048        readonly parent: TemplateLiteralTypeNode;
1049        readonly type: TypeNode;
1050        readonly literal: TemplateMiddle | TemplateTail;
1051    }
1052    export interface Expression extends Node {
1053        _expressionBrand: any;
1054    }
1055    export interface OmittedExpression extends Expression {
1056        readonly kind: SyntaxKind.OmittedExpression;
1057    }
1058    export interface PartiallyEmittedExpression extends LeftHandSideExpression {
1059        readonly kind: SyntaxKind.PartiallyEmittedExpression;
1060        readonly expression: Expression;
1061    }
1062    export interface UnaryExpression extends Expression {
1063        _unaryExpressionBrand: any;
1064    }
1065    /** Deprecated, please use UpdateExpression */
1066    export type IncrementExpression = UpdateExpression;
1067    export interface UpdateExpression extends UnaryExpression {
1068        _updateExpressionBrand: any;
1069    }
1070    export type PrefixUnaryOperator = SyntaxKind.PlusPlusToken | SyntaxKind.MinusMinusToken | SyntaxKind.PlusToken | SyntaxKind.MinusToken | SyntaxKind.TildeToken | SyntaxKind.ExclamationToken;
1071    export interface PrefixUnaryExpression extends UpdateExpression {
1072        readonly kind: SyntaxKind.PrefixUnaryExpression;
1073        readonly operator: PrefixUnaryOperator;
1074        readonly operand: UnaryExpression;
1075    }
1076    export type PostfixUnaryOperator = SyntaxKind.PlusPlusToken | SyntaxKind.MinusMinusToken;
1077    export interface PostfixUnaryExpression extends UpdateExpression {
1078        readonly kind: SyntaxKind.PostfixUnaryExpression;
1079        readonly operand: LeftHandSideExpression;
1080        readonly operator: PostfixUnaryOperator;
1081    }
1082    export interface LeftHandSideExpression extends UpdateExpression {
1083        _leftHandSideExpressionBrand: any;
1084    }
1085    export interface MemberExpression extends LeftHandSideExpression {
1086        _memberExpressionBrand: any;
1087    }
1088    export interface PrimaryExpression extends MemberExpression {
1089        _primaryExpressionBrand: any;
1090    }
1091    export interface NullLiteral extends PrimaryExpression {
1092        readonly kind: SyntaxKind.NullKeyword;
1093    }
1094    export interface TrueLiteral extends PrimaryExpression {
1095        readonly kind: SyntaxKind.TrueKeyword;
1096    }
1097    export interface FalseLiteral extends PrimaryExpression {
1098        readonly kind: SyntaxKind.FalseKeyword;
1099    }
1100    export type BooleanLiteral = TrueLiteral | FalseLiteral;
1101    export interface ThisExpression extends PrimaryExpression {
1102        readonly kind: SyntaxKind.ThisKeyword;
1103    }
1104    export interface SuperExpression extends PrimaryExpression {
1105        readonly kind: SyntaxKind.SuperKeyword;
1106    }
1107    export interface ImportExpression extends PrimaryExpression {
1108        readonly kind: SyntaxKind.ImportKeyword;
1109    }
1110    export interface DeleteExpression extends UnaryExpression {
1111        readonly kind: SyntaxKind.DeleteExpression;
1112        readonly expression: UnaryExpression;
1113    }
1114    export interface TypeOfExpression extends UnaryExpression {
1115        readonly kind: SyntaxKind.TypeOfExpression;
1116        readonly expression: UnaryExpression;
1117    }
1118    export interface VoidExpression extends UnaryExpression {
1119        readonly kind: SyntaxKind.VoidExpression;
1120        readonly expression: UnaryExpression;
1121    }
1122    export interface AwaitExpression extends UnaryExpression {
1123        readonly kind: SyntaxKind.AwaitExpression;
1124        readonly expression: UnaryExpression;
1125    }
1126    export interface YieldExpression extends Expression {
1127        readonly kind: SyntaxKind.YieldExpression;
1128        readonly asteriskToken?: AsteriskToken;
1129        readonly expression?: Expression;
1130    }
1131    export interface SyntheticExpression extends Expression {
1132        readonly kind: SyntaxKind.SyntheticExpression;
1133        readonly isSpread: boolean;
1134        readonly type: Type;
1135        readonly tupleNameSource?: ParameterDeclaration | NamedTupleMember;
1136    }
1137    export type ExponentiationOperator = SyntaxKind.AsteriskAsteriskToken;
1138    export type MultiplicativeOperator = SyntaxKind.AsteriskToken | SyntaxKind.SlashToken | SyntaxKind.PercentToken;
1139    export type MultiplicativeOperatorOrHigher = ExponentiationOperator | MultiplicativeOperator;
1140    export type AdditiveOperator = SyntaxKind.PlusToken | SyntaxKind.MinusToken;
1141    export type AdditiveOperatorOrHigher = MultiplicativeOperatorOrHigher | AdditiveOperator;
1142    export type ShiftOperator = SyntaxKind.LessThanLessThanToken | SyntaxKind.GreaterThanGreaterThanToken | SyntaxKind.GreaterThanGreaterThanGreaterThanToken;
1143    export type ShiftOperatorOrHigher = AdditiveOperatorOrHigher | ShiftOperator;
1144    export type RelationalOperator = SyntaxKind.LessThanToken | SyntaxKind.LessThanEqualsToken | SyntaxKind.GreaterThanToken | SyntaxKind.GreaterThanEqualsToken | SyntaxKind.InstanceOfKeyword | SyntaxKind.InKeyword;
1145    export type RelationalOperatorOrHigher = ShiftOperatorOrHigher | RelationalOperator;
1146    export type EqualityOperator = SyntaxKind.EqualsEqualsToken | SyntaxKind.EqualsEqualsEqualsToken | SyntaxKind.ExclamationEqualsEqualsToken | SyntaxKind.ExclamationEqualsToken;
1147    export type EqualityOperatorOrHigher = RelationalOperatorOrHigher | EqualityOperator;
1148    export type BitwiseOperator = SyntaxKind.AmpersandToken | SyntaxKind.BarToken | SyntaxKind.CaretToken;
1149    export type BitwiseOperatorOrHigher = EqualityOperatorOrHigher | BitwiseOperator;
1150    export type LogicalOperator = SyntaxKind.AmpersandAmpersandToken | SyntaxKind.BarBarToken;
1151    export type LogicalOperatorOrHigher = BitwiseOperatorOrHigher | LogicalOperator;
1152    export type CompoundAssignmentOperator = SyntaxKind.PlusEqualsToken | SyntaxKind.MinusEqualsToken | SyntaxKind.AsteriskAsteriskEqualsToken | SyntaxKind.AsteriskEqualsToken | SyntaxKind.SlashEqualsToken | SyntaxKind.PercentEqualsToken | SyntaxKind.AmpersandEqualsToken | SyntaxKind.BarEqualsToken | SyntaxKind.CaretEqualsToken | SyntaxKind.LessThanLessThanEqualsToken | SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken | SyntaxKind.GreaterThanGreaterThanEqualsToken | SyntaxKind.BarBarEqualsToken | SyntaxKind.AmpersandAmpersandEqualsToken | SyntaxKind.QuestionQuestionEqualsToken;
1153    export type AssignmentOperator = SyntaxKind.EqualsToken | CompoundAssignmentOperator;
1154    export type AssignmentOperatorOrHigher = SyntaxKind.QuestionQuestionToken | LogicalOperatorOrHigher | AssignmentOperator;
1155    export type BinaryOperator = AssignmentOperatorOrHigher | SyntaxKind.CommaToken;
1156    export type LogicalOrCoalescingAssignmentOperator = SyntaxKind.AmpersandAmpersandEqualsToken | SyntaxKind.BarBarEqualsToken | SyntaxKind.QuestionQuestionEqualsToken;
1157    export type BinaryOperatorToken = Token<BinaryOperator>;
1158    export interface BinaryExpression extends Expression, Declaration {
1159        readonly kind: SyntaxKind.BinaryExpression;
1160        readonly left: Expression;
1161        readonly operatorToken: BinaryOperatorToken;
1162        readonly right: Expression;
1163    }
1164    export type AssignmentOperatorToken = Token<AssignmentOperator>;
1165    export interface AssignmentExpression<TOperator extends AssignmentOperatorToken> extends BinaryExpression {
1166        readonly left: LeftHandSideExpression;
1167        readonly operatorToken: TOperator;
1168    }
1169    export interface ObjectDestructuringAssignment extends AssignmentExpression<EqualsToken> {
1170        readonly left: ObjectLiteralExpression;
1171    }
1172    export interface ArrayDestructuringAssignment extends AssignmentExpression<EqualsToken> {
1173        readonly left: ArrayLiteralExpression;
1174    }
1175    export type DestructuringAssignment = ObjectDestructuringAssignment | ArrayDestructuringAssignment;
1176    export type BindingOrAssignmentElement = VariableDeclaration | ParameterDeclaration | ObjectBindingOrAssignmentElement | ArrayBindingOrAssignmentElement;
1177    export type ObjectBindingOrAssignmentElement = BindingElement | PropertyAssignment | ShorthandPropertyAssignment | SpreadAssignment;
1178    export type ArrayBindingOrAssignmentElement = BindingElement | OmittedExpression | SpreadElement | ArrayLiteralExpression | ObjectLiteralExpression | AssignmentExpression<EqualsToken> | Identifier | PropertyAccessExpression | ElementAccessExpression;
1179    export type BindingOrAssignmentElementRestIndicator = DotDotDotToken | SpreadElement | SpreadAssignment;
1180    export type BindingOrAssignmentElementTarget = BindingOrAssignmentPattern | Identifier | PropertyAccessExpression | ElementAccessExpression | OmittedExpression;
1181    export type ObjectBindingOrAssignmentPattern = ObjectBindingPattern | ObjectLiteralExpression;
1182    export type ArrayBindingOrAssignmentPattern = ArrayBindingPattern | ArrayLiteralExpression;
1183    export type AssignmentPattern = ObjectLiteralExpression | ArrayLiteralExpression;
1184    export type BindingOrAssignmentPattern = ObjectBindingOrAssignmentPattern | ArrayBindingOrAssignmentPattern;
1185    export interface ConditionalExpression extends Expression {
1186        readonly kind: SyntaxKind.ConditionalExpression;
1187        readonly condition: Expression;
1188        readonly questionToken: QuestionToken;
1189        readonly whenTrue: Expression;
1190        readonly colonToken: ColonToken;
1191        readonly whenFalse: Expression;
1192    }
1193    export type FunctionBody = Block;
1194    export type ConciseBody = FunctionBody | Expression;
1195    export interface FunctionExpression extends PrimaryExpression, FunctionLikeDeclarationBase, JSDocContainer {
1196        readonly kind: SyntaxKind.FunctionExpression;
1197        readonly modifiers?: NodeArray<Modifier>;
1198        readonly name?: Identifier;
1199        readonly body: FunctionBody;
1200    }
1201    export interface EtsComponentExpression extends PrimaryExpression, Declaration {
1202        readonly kind: SyntaxKind.EtsComponentExpression;
1203        readonly expression: LeftHandSideExpression;
1204        readonly typeArguments?: NodeArray<TypeNode>;
1205        readonly arguments: NodeArray<Expression>;
1206        readonly body?: Block;
1207    }
1208    export interface ArrowFunction extends Expression, FunctionLikeDeclarationBase, JSDocContainer {
1209        readonly kind: SyntaxKind.ArrowFunction;
1210        readonly modifiers?: NodeArray<Modifier>;
1211        readonly equalsGreaterThanToken: EqualsGreaterThanToken;
1212        readonly body: ConciseBody;
1213        readonly name: never;
1214    }
1215    export interface LiteralLikeNode extends Node {
1216        text: string;
1217        isUnterminated?: boolean;
1218        hasExtendedUnicodeEscape?: boolean;
1219    }
1220    export interface TemplateLiteralLikeNode extends LiteralLikeNode {
1221        rawText?: string;
1222    }
1223    export interface LiteralExpression extends LiteralLikeNode, PrimaryExpression {
1224        _literalExpressionBrand: any;
1225    }
1226    export interface RegularExpressionLiteral extends LiteralExpression {
1227        readonly kind: SyntaxKind.RegularExpressionLiteral;
1228    }
1229    export interface NoSubstitutionTemplateLiteral extends LiteralExpression, TemplateLiteralLikeNode, Declaration {
1230        readonly kind: SyntaxKind.NoSubstitutionTemplateLiteral;
1231    }
1232    export enum TokenFlags {
1233        None = 0,
1234        Scientific = 16,
1235        Octal = 32,
1236        HexSpecifier = 64,
1237        BinarySpecifier = 128,
1238        OctalSpecifier = 256,
1239    }
1240    export interface NumericLiteral extends LiteralExpression, Declaration {
1241        readonly kind: SyntaxKind.NumericLiteral;
1242    }
1243    export interface BigIntLiteral extends LiteralExpression {
1244        readonly kind: SyntaxKind.BigIntLiteral;
1245    }
1246    export type LiteralToken = NumericLiteral | BigIntLiteral | StringLiteral | JsxText | RegularExpressionLiteral | NoSubstitutionTemplateLiteral;
1247    export interface TemplateHead extends TemplateLiteralLikeNode {
1248        readonly kind: SyntaxKind.TemplateHead;
1249        readonly parent: TemplateExpression | TemplateLiteralTypeNode;
1250    }
1251    export interface TemplateMiddle extends TemplateLiteralLikeNode {
1252        readonly kind: SyntaxKind.TemplateMiddle;
1253        readonly parent: TemplateSpan | TemplateLiteralTypeSpan;
1254    }
1255    export interface TemplateTail extends TemplateLiteralLikeNode {
1256        readonly kind: SyntaxKind.TemplateTail;
1257        readonly parent: TemplateSpan | TemplateLiteralTypeSpan;
1258    }
1259    export type PseudoLiteralToken = TemplateHead | TemplateMiddle | TemplateTail;
1260    export type TemplateLiteralToken = NoSubstitutionTemplateLiteral | PseudoLiteralToken;
1261    export interface TemplateExpression extends PrimaryExpression {
1262        readonly kind: SyntaxKind.TemplateExpression;
1263        readonly head: TemplateHead;
1264        readonly templateSpans: NodeArray<TemplateSpan>;
1265    }
1266    export type TemplateLiteral = TemplateExpression | NoSubstitutionTemplateLiteral;
1267    export interface TemplateSpan extends Node {
1268        readonly kind: SyntaxKind.TemplateSpan;
1269        readonly parent: TemplateExpression;
1270        readonly expression: Expression;
1271        readonly literal: TemplateMiddle | TemplateTail;
1272    }
1273    export interface ParenthesizedExpression extends PrimaryExpression, JSDocContainer {
1274        readonly kind: SyntaxKind.ParenthesizedExpression;
1275        readonly expression: Expression;
1276    }
1277    export interface ArrayLiteralExpression extends PrimaryExpression {
1278        readonly kind: SyntaxKind.ArrayLiteralExpression;
1279        readonly elements: NodeArray<Expression>;
1280    }
1281    export interface SpreadElement extends Expression {
1282        readonly kind: SyntaxKind.SpreadElement;
1283        readonly parent: ArrayLiteralExpression | CallExpression | NewExpression;
1284        readonly expression: Expression;
1285    }
1286    /**
1287     * This interface is a base interface for ObjectLiteralExpression and JSXAttributes to extend from. JSXAttributes is similar to
1288     * ObjectLiteralExpression in that it contains array of properties; however, JSXAttributes' properties can only be
1289     * JSXAttribute or JSXSpreadAttribute. ObjectLiteralExpression, on the other hand, can only have properties of type
1290     * ObjectLiteralElement (e.g. PropertyAssignment, ShorthandPropertyAssignment etc.)
1291     */
1292    export interface ObjectLiteralExpressionBase<T extends ObjectLiteralElement> extends PrimaryExpression, Declaration {
1293        readonly properties: NodeArray<T>;
1294    }
1295    export interface ObjectLiteralExpression extends ObjectLiteralExpressionBase<ObjectLiteralElementLike> {
1296        readonly kind: SyntaxKind.ObjectLiteralExpression;
1297    }
1298    export type EntityNameExpression = Identifier | PropertyAccessEntityNameExpression;
1299    export type EntityNameOrEntityNameExpression = EntityName | EntityNameExpression;
1300    export type AccessExpression = PropertyAccessExpression | ElementAccessExpression;
1301    export interface PropertyAccessExpression extends MemberExpression, NamedDeclaration {
1302        readonly kind: SyntaxKind.PropertyAccessExpression;
1303        readonly expression: LeftHandSideExpression;
1304        readonly questionDotToken?: QuestionDotToken;
1305        readonly name: MemberName;
1306    }
1307    export interface PropertyAccessChain extends PropertyAccessExpression {
1308        _optionalChainBrand: any;
1309        readonly name: MemberName;
1310    }
1311    export interface SuperPropertyAccessExpression extends PropertyAccessExpression {
1312        readonly expression: SuperExpression;
1313    }
1314    /** Brand for a PropertyAccessExpression which, like a QualifiedName, consists of a sequence of identifiers separated by dots. */
1315    export interface PropertyAccessEntityNameExpression extends PropertyAccessExpression {
1316        _propertyAccessExpressionLikeQualifiedNameBrand?: any;
1317        readonly expression: EntityNameExpression;
1318        readonly name: Identifier;
1319    }
1320    export interface ElementAccessExpression extends MemberExpression {
1321        readonly kind: SyntaxKind.ElementAccessExpression;
1322        readonly expression: LeftHandSideExpression;
1323        readonly questionDotToken?: QuestionDotToken;
1324        readonly argumentExpression: Expression;
1325    }
1326    export interface ElementAccessChain extends ElementAccessExpression {
1327        _optionalChainBrand: any;
1328    }
1329    export interface SuperElementAccessExpression extends ElementAccessExpression {
1330        readonly expression: SuperExpression;
1331    }
1332    export type SuperProperty = SuperPropertyAccessExpression | SuperElementAccessExpression;
1333    export interface CallExpression extends LeftHandSideExpression, Declaration {
1334        readonly kind: SyntaxKind.CallExpression;
1335        readonly expression: LeftHandSideExpression;
1336        readonly questionDotToken?: QuestionDotToken;
1337        readonly typeArguments?: NodeArray<TypeNode>;
1338        readonly arguments: NodeArray<Expression>;
1339    }
1340    export interface CallChain extends CallExpression {
1341        _optionalChainBrand: any;
1342    }
1343    export type OptionalChain = PropertyAccessChain | ElementAccessChain | CallChain | NonNullChain;
1344    export interface SuperCall extends CallExpression {
1345        readonly expression: SuperExpression;
1346    }
1347    export interface ImportCall extends CallExpression {
1348        readonly expression: ImportExpression;
1349    }
1350    export interface ExpressionWithTypeArguments extends MemberExpression, NodeWithTypeArguments {
1351        readonly kind: SyntaxKind.ExpressionWithTypeArguments;
1352        readonly expression: LeftHandSideExpression;
1353    }
1354    export interface NewExpression extends PrimaryExpression, Declaration {
1355        readonly kind: SyntaxKind.NewExpression;
1356        readonly expression: LeftHandSideExpression;
1357        readonly typeArguments?: NodeArray<TypeNode>;
1358        readonly arguments?: NodeArray<Expression>;
1359    }
1360    export interface TaggedTemplateExpression extends MemberExpression {
1361        readonly kind: SyntaxKind.TaggedTemplateExpression;
1362        readonly tag: LeftHandSideExpression;
1363        readonly typeArguments?: NodeArray<TypeNode>;
1364        readonly template: TemplateLiteral;
1365    }
1366    export type CallLikeExpression = CallExpression | NewExpression | TaggedTemplateExpression | Decorator | JsxOpeningLikeElement | EtsComponentExpression;
1367    export interface AsExpression extends Expression {
1368        readonly kind: SyntaxKind.AsExpression;
1369        readonly expression: Expression;
1370        readonly type: TypeNode;
1371    }
1372    export interface TypeAssertion extends UnaryExpression {
1373        readonly kind: SyntaxKind.TypeAssertionExpression;
1374        readonly type: TypeNode;
1375        readonly expression: UnaryExpression;
1376    }
1377    export interface SatisfiesExpression extends Expression {
1378        readonly kind: SyntaxKind.SatisfiesExpression;
1379        readonly expression: Expression;
1380        readonly type: TypeNode;
1381    }
1382    export type AssertionExpression = TypeAssertion | AsExpression;
1383    export interface NonNullExpression extends LeftHandSideExpression {
1384        readonly kind: SyntaxKind.NonNullExpression;
1385        readonly expression: Expression;
1386    }
1387    export interface NonNullChain extends NonNullExpression {
1388        _optionalChainBrand: any;
1389    }
1390    export interface MetaProperty extends PrimaryExpression {
1391        readonly kind: SyntaxKind.MetaProperty;
1392        readonly keywordToken: SyntaxKind.NewKeyword | SyntaxKind.ImportKeyword;
1393        readonly name: Identifier;
1394    }
1395    export interface JsxElement extends PrimaryExpression {
1396        readonly kind: SyntaxKind.JsxElement;
1397        readonly openingElement: JsxOpeningElement;
1398        readonly children: NodeArray<JsxChild>;
1399        readonly closingElement: JsxClosingElement;
1400    }
1401    export type JsxOpeningLikeElement = JsxSelfClosingElement | JsxOpeningElement;
1402    export type JsxAttributeLike = JsxAttribute | JsxSpreadAttribute;
1403    export type JsxTagNameExpression = Identifier | ThisExpression | JsxTagNamePropertyAccess;
1404    export interface JsxTagNamePropertyAccess extends PropertyAccessExpression {
1405        readonly expression: JsxTagNameExpression;
1406    }
1407    export interface JsxAttributes extends ObjectLiteralExpressionBase<JsxAttributeLike> {
1408        readonly kind: SyntaxKind.JsxAttributes;
1409        readonly parent: JsxOpeningLikeElement;
1410    }
1411    export interface JsxOpeningElement extends Expression {
1412        readonly kind: SyntaxKind.JsxOpeningElement;
1413        readonly parent: JsxElement;
1414        readonly tagName: JsxTagNameExpression;
1415        readonly typeArguments?: NodeArray<TypeNode>;
1416        readonly attributes: JsxAttributes;
1417    }
1418    export interface JsxSelfClosingElement extends PrimaryExpression {
1419        readonly kind: SyntaxKind.JsxSelfClosingElement;
1420        readonly tagName: JsxTagNameExpression;
1421        readonly typeArguments?: NodeArray<TypeNode>;
1422        readonly attributes: JsxAttributes;
1423    }
1424    export interface JsxFragment extends PrimaryExpression {
1425        readonly kind: SyntaxKind.JsxFragment;
1426        readonly openingFragment: JsxOpeningFragment;
1427        readonly children: NodeArray<JsxChild>;
1428        readonly closingFragment: JsxClosingFragment;
1429    }
1430    export interface JsxOpeningFragment extends Expression {
1431        readonly kind: SyntaxKind.JsxOpeningFragment;
1432        readonly parent: JsxFragment;
1433    }
1434    export interface JsxClosingFragment extends Expression {
1435        readonly kind: SyntaxKind.JsxClosingFragment;
1436        readonly parent: JsxFragment;
1437    }
1438    export interface JsxAttribute extends ObjectLiteralElement {
1439        readonly kind: SyntaxKind.JsxAttribute;
1440        readonly parent: JsxAttributes;
1441        readonly name: Identifier;
1442        readonly initializer?: JsxAttributeValue;
1443    }
1444    export type JsxAttributeValue = StringLiteral | JsxExpression | JsxElement | JsxSelfClosingElement | JsxFragment;
1445    export interface JsxSpreadAttribute extends ObjectLiteralElement {
1446        readonly kind: SyntaxKind.JsxSpreadAttribute;
1447        readonly parent: JsxAttributes;
1448        readonly expression: Expression;
1449    }
1450    export interface JsxClosingElement extends Node {
1451        readonly kind: SyntaxKind.JsxClosingElement;
1452        readonly parent: JsxElement;
1453        readonly tagName: JsxTagNameExpression;
1454    }
1455    export interface JsxExpression extends Expression {
1456        readonly kind: SyntaxKind.JsxExpression;
1457        readonly parent: JsxElement | JsxFragment | JsxAttributeLike;
1458        readonly dotDotDotToken?: Token<SyntaxKind.DotDotDotToken>;
1459        readonly expression?: Expression;
1460    }
1461    export interface JsxText extends LiteralLikeNode {
1462        readonly kind: SyntaxKind.JsxText;
1463        readonly parent: JsxElement | JsxFragment;
1464        readonly containsOnlyTriviaWhiteSpaces: boolean;
1465    }
1466    export type JsxChild = JsxText | JsxExpression | JsxElement | JsxSelfClosingElement | JsxFragment;
1467    export interface Statement extends Node, JSDocContainer {
1468        _statementBrand: any;
1469    }
1470    export interface NotEmittedStatement extends Statement {
1471        readonly kind: SyntaxKind.NotEmittedStatement;
1472    }
1473    /**
1474     * A list of comma-separated expressions. This node is only created by transformations.
1475     */
1476    export interface CommaListExpression extends Expression {
1477        readonly kind: SyntaxKind.CommaListExpression;
1478        readonly elements: NodeArray<Expression>;
1479    }
1480    export interface EmptyStatement extends Statement {
1481        readonly kind: SyntaxKind.EmptyStatement;
1482    }
1483    export interface DebuggerStatement extends Statement {
1484        readonly kind: SyntaxKind.DebuggerStatement;
1485    }
1486    export interface MissingDeclaration extends DeclarationStatement {
1487        readonly kind: SyntaxKind.MissingDeclaration;
1488        readonly name?: Identifier;
1489    }
1490    export type BlockLike = SourceFile | Block | ModuleBlock | CaseOrDefaultClause;
1491    export interface Block extends Statement {
1492        readonly kind: SyntaxKind.Block;
1493        readonly statements: NodeArray<Statement>;
1494    }
1495    export interface VariableStatement extends Statement {
1496        readonly kind: SyntaxKind.VariableStatement;
1497        readonly modifiers?: NodeArray<Modifier>;
1498        readonly declarationList: VariableDeclarationList;
1499    }
1500    export interface ExpressionStatement extends Statement {
1501        readonly kind: SyntaxKind.ExpressionStatement;
1502        readonly expression: Expression;
1503    }
1504    export interface IfStatement extends Statement {
1505        readonly kind: SyntaxKind.IfStatement;
1506        readonly expression: Expression;
1507        readonly thenStatement: Statement;
1508        readonly elseStatement?: Statement;
1509    }
1510    export interface IterationStatement extends Statement {
1511        readonly statement: Statement;
1512    }
1513    export interface DoStatement extends IterationStatement {
1514        readonly kind: SyntaxKind.DoStatement;
1515        readonly expression: Expression;
1516    }
1517    export interface WhileStatement extends IterationStatement {
1518        readonly kind: SyntaxKind.WhileStatement;
1519        readonly expression: Expression;
1520    }
1521    export type ForInitializer = VariableDeclarationList | Expression;
1522    export interface ForStatement extends IterationStatement {
1523        readonly kind: SyntaxKind.ForStatement;
1524        readonly initializer?: ForInitializer;
1525        readonly condition?: Expression;
1526        readonly incrementor?: Expression;
1527    }
1528    export type ForInOrOfStatement = ForInStatement | ForOfStatement;
1529    export interface ForInStatement extends IterationStatement {
1530        readonly kind: SyntaxKind.ForInStatement;
1531        readonly initializer: ForInitializer;
1532        readonly expression: Expression;
1533    }
1534    export interface ForOfStatement extends IterationStatement {
1535        readonly kind: SyntaxKind.ForOfStatement;
1536        readonly awaitModifier?: AwaitKeyword;
1537        readonly initializer: ForInitializer;
1538        readonly expression: Expression;
1539    }
1540    export interface BreakStatement extends Statement {
1541        readonly kind: SyntaxKind.BreakStatement;
1542        readonly label?: Identifier;
1543    }
1544    export interface ContinueStatement extends Statement {
1545        readonly kind: SyntaxKind.ContinueStatement;
1546        readonly label?: Identifier;
1547    }
1548    export type BreakOrContinueStatement = BreakStatement | ContinueStatement;
1549    export interface ReturnStatement extends Statement {
1550        readonly kind: SyntaxKind.ReturnStatement;
1551        readonly expression?: Expression;
1552    }
1553    export interface WithStatement extends Statement {
1554        readonly kind: SyntaxKind.WithStatement;
1555        readonly expression: Expression;
1556        readonly statement: Statement;
1557    }
1558    export interface SwitchStatement extends Statement {
1559        readonly kind: SyntaxKind.SwitchStatement;
1560        readonly expression: Expression;
1561        readonly caseBlock: CaseBlock;
1562        possiblyExhaustive?: boolean;
1563    }
1564    export interface CaseBlock extends Node {
1565        readonly kind: SyntaxKind.CaseBlock;
1566        readonly parent: SwitchStatement;
1567        readonly clauses: NodeArray<CaseOrDefaultClause>;
1568    }
1569    export interface CaseClause extends Node, JSDocContainer {
1570        readonly kind: SyntaxKind.CaseClause;
1571        readonly parent: CaseBlock;
1572        readonly expression: Expression;
1573        readonly statements: NodeArray<Statement>;
1574    }
1575    export interface DefaultClause extends Node {
1576        readonly kind: SyntaxKind.DefaultClause;
1577        readonly parent: CaseBlock;
1578        readonly statements: NodeArray<Statement>;
1579    }
1580    export type CaseOrDefaultClause = CaseClause | DefaultClause;
1581    export interface LabeledStatement extends Statement {
1582        readonly kind: SyntaxKind.LabeledStatement;
1583        readonly label: Identifier;
1584        readonly statement: Statement;
1585    }
1586    export interface ThrowStatement extends Statement {
1587        readonly kind: SyntaxKind.ThrowStatement;
1588        readonly expression: Expression;
1589    }
1590    export interface TryStatement extends Statement {
1591        readonly kind: SyntaxKind.TryStatement;
1592        readonly tryBlock: Block;
1593        readonly catchClause?: CatchClause;
1594        readonly finallyBlock?: Block;
1595    }
1596    export interface CatchClause extends Node {
1597        readonly kind: SyntaxKind.CatchClause;
1598        readonly parent: TryStatement;
1599        readonly variableDeclaration?: VariableDeclaration;
1600        readonly block: Block;
1601    }
1602    export type ObjectTypeDeclaration = ClassLikeDeclaration | InterfaceDeclaration | TypeLiteralNode;
1603    export type DeclarationWithTypeParameters = DeclarationWithTypeParameterChildren | JSDocTypedefTag | JSDocCallbackTag | JSDocSignature;
1604    export type DeclarationWithTypeParameterChildren = SignatureDeclaration | ClassLikeDeclaration | InterfaceDeclaration | TypeAliasDeclaration | JSDocTemplateTag;
1605    export interface ClassLikeDeclarationBase extends NamedDeclaration, JSDocContainer {
1606        readonly kind: SyntaxKind.ClassDeclaration | SyntaxKind.ClassExpression | SyntaxKind.StructDeclaration;
1607        readonly name?: Identifier;
1608        readonly typeParameters?: NodeArray<TypeParameterDeclaration>;
1609        readonly heritageClauses?: NodeArray<HeritageClause>;
1610        readonly members: NodeArray<ClassElement>;
1611    }
1612    export interface ClassDeclaration extends ClassLikeDeclarationBase, DeclarationStatement {
1613        readonly kind: SyntaxKind.ClassDeclaration;
1614        readonly modifiers?: NodeArray<ModifierLike>;
1615        /** May be undefined in `export default class { ... }`. */
1616        readonly name?: Identifier;
1617    }
1618    export interface StructDeclaration extends ClassLikeDeclarationBase, DeclarationStatement {
1619        readonly kind: SyntaxKind.StructDeclaration;
1620        readonly modifiers?: NodeArray<ModifierLike>;
1621        /** May be undefined in `export default class { ... }`. */
1622        readonly name?: Identifier;
1623    }
1624    export interface ClassExpression extends ClassLikeDeclarationBase, PrimaryExpression {
1625        readonly kind: SyntaxKind.ClassExpression;
1626        readonly modifiers?: NodeArray<ModifierLike>;
1627    }
1628    export type ClassLikeDeclaration = ClassDeclaration | ClassExpression | StructDeclaration;
1629    export interface ClassElement extends NamedDeclaration {
1630        _classElementBrand: any;
1631        readonly name?: PropertyName;
1632    }
1633    export interface TypeElement extends NamedDeclaration {
1634        _typeElementBrand: any;
1635        readonly name?: PropertyName;
1636        readonly questionToken?: QuestionToken | undefined;
1637    }
1638    export interface InterfaceDeclaration extends DeclarationStatement, JSDocContainer {
1639        readonly kind: SyntaxKind.InterfaceDeclaration;
1640        readonly modifiers?: NodeArray<Modifier>;
1641        readonly name: Identifier;
1642        readonly typeParameters?: NodeArray<TypeParameterDeclaration>;
1643        readonly heritageClauses?: NodeArray<HeritageClause>;
1644        readonly members: NodeArray<TypeElement>;
1645    }
1646    export interface HeritageClause extends Node {
1647        readonly kind: SyntaxKind.HeritageClause;
1648        readonly parent: InterfaceDeclaration | ClassLikeDeclaration;
1649        readonly token: SyntaxKind.ExtendsKeyword | SyntaxKind.ImplementsKeyword;
1650        readonly types: NodeArray<ExpressionWithTypeArguments>;
1651    }
1652    export interface TypeAliasDeclaration extends DeclarationStatement, JSDocContainer {
1653        readonly kind: SyntaxKind.TypeAliasDeclaration;
1654        readonly modifiers?: NodeArray<Modifier>;
1655        readonly name: Identifier;
1656        readonly typeParameters?: NodeArray<TypeParameterDeclaration>;
1657        readonly type: TypeNode;
1658    }
1659    export interface EnumMember extends NamedDeclaration, JSDocContainer {
1660        readonly kind: SyntaxKind.EnumMember;
1661        readonly parent: EnumDeclaration;
1662        readonly name: PropertyName;
1663        readonly initializer?: Expression;
1664    }
1665    export interface EnumDeclaration extends DeclarationStatement, JSDocContainer {
1666        readonly kind: SyntaxKind.EnumDeclaration;
1667        readonly modifiers?: NodeArray<Modifier>;
1668        readonly name: Identifier;
1669        readonly members: NodeArray<EnumMember>;
1670    }
1671    export type ModuleName = Identifier | StringLiteral;
1672    export type ModuleBody = NamespaceBody | JSDocNamespaceBody;
1673    export interface ModuleDeclaration extends DeclarationStatement, JSDocContainer {
1674        readonly kind: SyntaxKind.ModuleDeclaration;
1675        readonly parent: ModuleBody | SourceFile;
1676        readonly modifiers?: NodeArray<Modifier>;
1677        readonly name: ModuleName;
1678        readonly body?: ModuleBody | JSDocNamespaceDeclaration;
1679    }
1680    export type NamespaceBody = ModuleBlock | NamespaceDeclaration;
1681    export interface NamespaceDeclaration extends ModuleDeclaration {
1682        readonly name: Identifier;
1683        readonly body: NamespaceBody;
1684    }
1685    export type JSDocNamespaceBody = Identifier | JSDocNamespaceDeclaration;
1686    export interface JSDocNamespaceDeclaration extends ModuleDeclaration {
1687        readonly name: Identifier;
1688        readonly body?: JSDocNamespaceBody;
1689    }
1690    export interface ModuleBlock extends Node, Statement {
1691        readonly kind: SyntaxKind.ModuleBlock;
1692        readonly parent: ModuleDeclaration;
1693        readonly statements: NodeArray<Statement>;
1694    }
1695    export type ModuleReference = EntityName | ExternalModuleReference;
1696    /**
1697     * One of:
1698     * - import x = require("mod");
1699     * - import x = M.x;
1700     */
1701    export interface ImportEqualsDeclaration extends DeclarationStatement, JSDocContainer {
1702        readonly kind: SyntaxKind.ImportEqualsDeclaration;
1703        readonly parent: SourceFile | ModuleBlock;
1704        readonly modifiers?: NodeArray<Modifier>;
1705        readonly name: Identifier;
1706        readonly isTypeOnly: boolean;
1707        readonly moduleReference: ModuleReference;
1708    }
1709    export interface ExternalModuleReference extends Node {
1710        readonly kind: SyntaxKind.ExternalModuleReference;
1711        readonly parent: ImportEqualsDeclaration;
1712        readonly expression: Expression;
1713    }
1714    export interface ImportDeclaration extends Statement {
1715        readonly kind: SyntaxKind.ImportDeclaration;
1716        readonly parent: SourceFile | ModuleBlock;
1717        readonly modifiers?: NodeArray<Modifier>;
1718        readonly importClause?: ImportClause;
1719        /** If this is not a StringLiteral it will be a grammar error. */
1720        readonly moduleSpecifier: Expression;
1721        readonly assertClause?: AssertClause;
1722    }
1723    export type NamedImportBindings = NamespaceImport | NamedImports;
1724    export type NamedExportBindings = NamespaceExport | NamedExports;
1725    export interface ImportClause extends NamedDeclaration {
1726        readonly kind: SyntaxKind.ImportClause;
1727        readonly parent: ImportDeclaration;
1728        readonly isTypeOnly: boolean;
1729        readonly name?: Identifier;
1730        readonly namedBindings?: NamedImportBindings;
1731    }
1732    export type AssertionKey = Identifier | StringLiteral;
1733    export interface AssertEntry extends Node {
1734        readonly kind: SyntaxKind.AssertEntry;
1735        readonly parent: AssertClause;
1736        readonly name: AssertionKey;
1737        readonly value: Expression;
1738    }
1739    export interface AssertClause extends Node {
1740        readonly kind: SyntaxKind.AssertClause;
1741        readonly parent: ImportDeclaration | ExportDeclaration;
1742        readonly elements: NodeArray<AssertEntry>;
1743        readonly multiLine?: boolean;
1744    }
1745    export interface NamespaceImport extends NamedDeclaration {
1746        readonly kind: SyntaxKind.NamespaceImport;
1747        readonly parent: ImportClause;
1748        readonly name: Identifier;
1749    }
1750    export interface NamespaceExport extends NamedDeclaration {
1751        readonly kind: SyntaxKind.NamespaceExport;
1752        readonly parent: ExportDeclaration;
1753        readonly name: Identifier;
1754    }
1755    export interface NamespaceExportDeclaration extends DeclarationStatement, JSDocContainer {
1756        readonly kind: SyntaxKind.NamespaceExportDeclaration;
1757        readonly name: Identifier;
1758    }
1759    export interface ExportDeclaration extends DeclarationStatement, JSDocContainer {
1760        readonly kind: SyntaxKind.ExportDeclaration;
1761        readonly parent: SourceFile | ModuleBlock;
1762        readonly modifiers?: NodeArray<Modifier>;
1763        readonly isTypeOnly: boolean;
1764        /** Will not be assigned in the case of `export * from "foo";` */
1765        readonly exportClause?: NamedExportBindings;
1766        /** If this is not a StringLiteral it will be a grammar error. */
1767        readonly moduleSpecifier?: Expression;
1768        readonly assertClause?: AssertClause;
1769    }
1770    export interface NamedImports extends Node {
1771        readonly kind: SyntaxKind.NamedImports;
1772        readonly parent: ImportClause;
1773        readonly elements: NodeArray<ImportSpecifier>;
1774    }
1775    export interface NamedExports extends Node {
1776        readonly kind: SyntaxKind.NamedExports;
1777        readonly parent: ExportDeclaration;
1778        readonly elements: NodeArray<ExportSpecifier>;
1779    }
1780    export type NamedImportsOrExports = NamedImports | NamedExports;
1781    export interface ImportSpecifier extends NamedDeclaration {
1782        readonly kind: SyntaxKind.ImportSpecifier;
1783        readonly parent: NamedImports;
1784        readonly propertyName?: Identifier;
1785        readonly name: Identifier;
1786        readonly isTypeOnly: boolean;
1787    }
1788    export interface ExportSpecifier extends NamedDeclaration, JSDocContainer {
1789        readonly kind: SyntaxKind.ExportSpecifier;
1790        readonly parent: NamedExports;
1791        readonly isTypeOnly: boolean;
1792        readonly propertyName?: Identifier;
1793        readonly name: Identifier;
1794    }
1795    export type ImportOrExportSpecifier = ImportSpecifier | ExportSpecifier;
1796    export type TypeOnlyCompatibleAliasDeclaration = ImportClause | ImportEqualsDeclaration | NamespaceImport | ImportOrExportSpecifier;
1797    export type TypeOnlyAliasDeclaration = ImportClause & {
1798        readonly isTypeOnly: true;
1799        readonly name: Identifier;
1800    } | ImportEqualsDeclaration & {
1801        readonly isTypeOnly: true;
1802    } | NamespaceImport & {
1803        readonly parent: ImportClause & {
1804            readonly isTypeOnly: true;
1805        };
1806    } | ImportSpecifier & ({
1807        readonly isTypeOnly: true;
1808    } | {
1809        readonly parent: NamedImports & {
1810            readonly parent: ImportClause & {
1811                readonly isTypeOnly: true;
1812            };
1813        };
1814    }) | ExportSpecifier & ({
1815        readonly isTypeOnly: true;
1816    } | {
1817        readonly parent: NamedExports & {
1818            readonly parent: ExportDeclaration & {
1819                readonly isTypeOnly: true;
1820            };
1821        };
1822    });
1823    /**
1824     * This is either an `export =` or an `export default` declaration.
1825     * Unless `isExportEquals` is set, this node was parsed as an `export default`.
1826     */
1827    export interface ExportAssignment extends DeclarationStatement, JSDocContainer {
1828        readonly kind: SyntaxKind.ExportAssignment;
1829        readonly parent: SourceFile;
1830        readonly modifiers?: NodeArray<Modifier>;
1831        readonly isExportEquals?: boolean;
1832        readonly expression: Expression;
1833    }
1834    export interface FileReference extends TextRange {
1835        fileName: string;
1836        resolutionMode?: SourceFile["impliedNodeFormat"];
1837    }
1838    export interface CheckJsDirective extends TextRange {
1839        enabled: boolean;
1840    }
1841    export type CommentKind = SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia;
1842    export interface CommentRange extends TextRange {
1843        hasTrailingNewLine?: boolean;
1844        kind: CommentKind;
1845    }
1846    export interface SynthesizedComment extends CommentRange {
1847        text: string;
1848        pos: -1;
1849        end: -1;
1850        hasLeadingNewline?: boolean;
1851    }
1852    export interface JSDocTypeExpression extends TypeNode {
1853        readonly kind: SyntaxKind.JSDocTypeExpression;
1854        readonly type: TypeNode;
1855    }
1856    export interface JSDocNameReference extends Node {
1857        readonly kind: SyntaxKind.JSDocNameReference;
1858        readonly name: EntityName | JSDocMemberName;
1859    }
1860    /** Class#method reference in JSDoc */
1861    export interface JSDocMemberName extends Node {
1862        readonly kind: SyntaxKind.JSDocMemberName;
1863        readonly left: EntityName | JSDocMemberName;
1864        readonly right: Identifier;
1865    }
1866    export interface JSDocType extends TypeNode {
1867        _jsDocTypeBrand: any;
1868    }
1869    export interface JSDocAllType extends JSDocType {
1870        readonly kind: SyntaxKind.JSDocAllType;
1871    }
1872    export interface JSDocUnknownType extends JSDocType {
1873        readonly kind: SyntaxKind.JSDocUnknownType;
1874    }
1875    export interface JSDocNonNullableType extends JSDocType {
1876        readonly kind: SyntaxKind.JSDocNonNullableType;
1877        readonly type: TypeNode;
1878        readonly postfix: boolean;
1879    }
1880    export interface JSDocNullableType extends JSDocType {
1881        readonly kind: SyntaxKind.JSDocNullableType;
1882        readonly type: TypeNode;
1883        readonly postfix: boolean;
1884    }
1885    export interface JSDocOptionalType extends JSDocType {
1886        readonly kind: SyntaxKind.JSDocOptionalType;
1887        readonly type: TypeNode;
1888    }
1889    export interface JSDocFunctionType extends JSDocType, SignatureDeclarationBase {
1890        readonly kind: SyntaxKind.JSDocFunctionType;
1891    }
1892    export interface JSDocVariadicType extends JSDocType {
1893        readonly kind: SyntaxKind.JSDocVariadicType;
1894        readonly type: TypeNode;
1895    }
1896    export interface JSDocNamepathType extends JSDocType {
1897        readonly kind: SyntaxKind.JSDocNamepathType;
1898        readonly type: TypeNode;
1899    }
1900    export type JSDocTypeReferencingNode = JSDocVariadicType | JSDocOptionalType | JSDocNullableType | JSDocNonNullableType;
1901    export interface JSDoc extends Node {
1902        readonly kind: SyntaxKind.JSDoc;
1903        readonly parent: HasJSDoc;
1904        readonly tags?: NodeArray<JSDocTag>;
1905        readonly comment?: string | NodeArray<JSDocComment>;
1906    }
1907    export interface JSDocTag extends Node {
1908        readonly parent: JSDoc | JSDocTypeLiteral;
1909        readonly tagName: Identifier;
1910        readonly comment?: string | NodeArray<JSDocComment>;
1911    }
1912    export interface JSDocLink extends Node {
1913        readonly kind: SyntaxKind.JSDocLink;
1914        readonly name?: EntityName | JSDocMemberName;
1915        text: string;
1916    }
1917    export interface JSDocLinkCode extends Node {
1918        readonly kind: SyntaxKind.JSDocLinkCode;
1919        readonly name?: EntityName | JSDocMemberName;
1920        text: string;
1921    }
1922    export interface JSDocLinkPlain extends Node {
1923        readonly kind: SyntaxKind.JSDocLinkPlain;
1924        readonly name?: EntityName | JSDocMemberName;
1925        text: string;
1926    }
1927    export type JSDocComment = JSDocText | JSDocLink | JSDocLinkCode | JSDocLinkPlain;
1928    export interface JSDocText extends Node {
1929        readonly kind: SyntaxKind.JSDocText;
1930        text: string;
1931    }
1932    export interface JSDocUnknownTag extends JSDocTag {
1933        readonly kind: SyntaxKind.JSDocTag;
1934    }
1935    /**
1936     * Note that `@extends` is a synonym of `@augments`.
1937     * Both tags are represented by this interface.
1938     */
1939    export interface JSDocAugmentsTag extends JSDocTag {
1940        readonly kind: SyntaxKind.JSDocAugmentsTag;
1941        readonly class: ExpressionWithTypeArguments & {
1942            readonly expression: Identifier | PropertyAccessEntityNameExpression;
1943        };
1944    }
1945    export interface JSDocImplementsTag extends JSDocTag {
1946        readonly kind: SyntaxKind.JSDocImplementsTag;
1947        readonly class: ExpressionWithTypeArguments & {
1948            readonly expression: Identifier | PropertyAccessEntityNameExpression;
1949        };
1950    }
1951    export interface JSDocAuthorTag extends JSDocTag {
1952        readonly kind: SyntaxKind.JSDocAuthorTag;
1953    }
1954    export interface JSDocDeprecatedTag extends JSDocTag {
1955        kind: SyntaxKind.JSDocDeprecatedTag;
1956    }
1957    export interface JSDocClassTag extends JSDocTag {
1958        readonly kind: SyntaxKind.JSDocClassTag;
1959    }
1960    export interface JSDocPublicTag extends JSDocTag {
1961        readonly kind: SyntaxKind.JSDocPublicTag;
1962    }
1963    export interface JSDocPrivateTag extends JSDocTag {
1964        readonly kind: SyntaxKind.JSDocPrivateTag;
1965    }
1966    export interface JSDocProtectedTag extends JSDocTag {
1967        readonly kind: SyntaxKind.JSDocProtectedTag;
1968    }
1969    export interface JSDocReadonlyTag extends JSDocTag {
1970        readonly kind: SyntaxKind.JSDocReadonlyTag;
1971    }
1972    export interface JSDocOverrideTag extends JSDocTag {
1973        readonly kind: SyntaxKind.JSDocOverrideTag;
1974    }
1975    export interface JSDocEnumTag extends JSDocTag, Declaration {
1976        readonly kind: SyntaxKind.JSDocEnumTag;
1977        readonly parent: JSDoc;
1978        readonly typeExpression: JSDocTypeExpression;
1979    }
1980    export interface JSDocThisTag extends JSDocTag {
1981        readonly kind: SyntaxKind.JSDocThisTag;
1982        readonly typeExpression: JSDocTypeExpression;
1983    }
1984    export interface JSDocTemplateTag extends JSDocTag {
1985        readonly kind: SyntaxKind.JSDocTemplateTag;
1986        readonly constraint: JSDocTypeExpression | undefined;
1987        readonly typeParameters: NodeArray<TypeParameterDeclaration>;
1988    }
1989    export interface JSDocSeeTag extends JSDocTag {
1990        readonly kind: SyntaxKind.JSDocSeeTag;
1991        readonly name?: JSDocNameReference;
1992    }
1993    export interface JSDocReturnTag extends JSDocTag {
1994        readonly kind: SyntaxKind.JSDocReturnTag;
1995        readonly typeExpression?: JSDocTypeExpression;
1996    }
1997    export interface JSDocTypeTag extends JSDocTag {
1998        readonly kind: SyntaxKind.JSDocTypeTag;
1999        readonly typeExpression: JSDocTypeExpression;
2000    }
2001    export interface JSDocTypedefTag extends JSDocTag, NamedDeclaration {
2002        readonly kind: SyntaxKind.JSDocTypedefTag;
2003        readonly parent: JSDoc;
2004        readonly fullName?: JSDocNamespaceDeclaration | Identifier;
2005        readonly name?: Identifier;
2006        readonly typeExpression?: JSDocTypeExpression | JSDocTypeLiteral;
2007    }
2008    export interface JSDocCallbackTag extends JSDocTag, NamedDeclaration {
2009        readonly kind: SyntaxKind.JSDocCallbackTag;
2010        readonly parent: JSDoc;
2011        readonly fullName?: JSDocNamespaceDeclaration | Identifier;
2012        readonly name?: Identifier;
2013        readonly typeExpression: JSDocSignature;
2014    }
2015    export interface JSDocSignature extends JSDocType, Declaration {
2016        readonly kind: SyntaxKind.JSDocSignature;
2017        readonly typeParameters?: readonly JSDocTemplateTag[];
2018        readonly parameters: readonly JSDocParameterTag[];
2019        readonly type: JSDocReturnTag | undefined;
2020    }
2021    export interface JSDocPropertyLikeTag extends JSDocTag, Declaration {
2022        readonly parent: JSDoc;
2023        readonly name: EntityName;
2024        readonly typeExpression?: JSDocTypeExpression;
2025        /** Whether the property name came before the type -- non-standard for JSDoc, but Typescript-like */
2026        readonly isNameFirst: boolean;
2027        readonly isBracketed: boolean;
2028    }
2029    export interface JSDocPropertyTag extends JSDocPropertyLikeTag {
2030        readonly kind: SyntaxKind.JSDocPropertyTag;
2031    }
2032    export interface JSDocParameterTag extends JSDocPropertyLikeTag {
2033        readonly kind: SyntaxKind.JSDocParameterTag;
2034    }
2035    export interface JSDocTypeLiteral extends JSDocType {
2036        readonly kind: SyntaxKind.JSDocTypeLiteral;
2037        readonly jsDocPropertyTags?: readonly JSDocPropertyLikeTag[];
2038        /** If true, then this type literal represents an *array* of its type. */
2039        readonly isArrayType: boolean;
2040    }
2041    export enum FlowFlags {
2042        Unreachable = 1,
2043        Start = 2,
2044        BranchLabel = 4,
2045        LoopLabel = 8,
2046        Assignment = 16,
2047        TrueCondition = 32,
2048        FalseCondition = 64,
2049        SwitchClause = 128,
2050        ArrayMutation = 256,
2051        Call = 512,
2052        ReduceLabel = 1024,
2053        Referenced = 2048,
2054        Shared = 4096,
2055        Label = 12,
2056        Condition = 96
2057    }
2058    export type FlowNode = FlowStart | FlowLabel | FlowAssignment | FlowCondition | FlowSwitchClause | FlowArrayMutation | FlowCall | FlowReduceLabel;
2059    export interface FlowNodeBase {
2060        flags: FlowFlags;
2061        id?: number;
2062    }
2063    export interface FlowStart extends FlowNodeBase {
2064        node?: FunctionExpression | ArrowFunction | MethodDeclaration | GetAccessorDeclaration | SetAccessorDeclaration;
2065    }
2066    export interface FlowLabel extends FlowNodeBase {
2067        antecedents: FlowNode[] | undefined;
2068    }
2069    export interface FlowAssignment extends FlowNodeBase {
2070        node: Expression | VariableDeclaration | BindingElement;
2071        antecedent: FlowNode;
2072    }
2073    export interface FlowCall extends FlowNodeBase {
2074        node: CallExpression;
2075        antecedent: FlowNode;
2076    }
2077    export interface FlowCondition extends FlowNodeBase {
2078        node: Expression;
2079        antecedent: FlowNode;
2080    }
2081    export interface FlowSwitchClause extends FlowNodeBase {
2082        switchStatement: SwitchStatement;
2083        clauseStart: number;
2084        clauseEnd: number;
2085        antecedent: FlowNode;
2086    }
2087    export interface FlowArrayMutation extends FlowNodeBase {
2088        node: CallExpression | BinaryExpression;
2089        antecedent: FlowNode;
2090    }
2091    export interface FlowReduceLabel extends FlowNodeBase {
2092        target: FlowLabel;
2093        antecedents: FlowNode[];
2094        antecedent: FlowNode;
2095    }
2096    export type FlowType = Type | IncompleteType;
2097    export interface IncompleteType {
2098        flags: TypeFlags;
2099        type: Type;
2100    }
2101    export interface AmdDependency {
2102        path: string;
2103        name?: string;
2104    }
2105    /**
2106     * Subset of properties from SourceFile that are used in multiple utility functions
2107     */
2108    export interface SourceFileLike {
2109        readonly text: string;
2110        readonly fileName?: string;
2111    }
2112    export interface SourceFile extends Declaration {
2113        readonly kind: SyntaxKind.SourceFile;
2114        readonly statements: NodeArray<Statement>;
2115        readonly endOfFileToken: Token<SyntaxKind.EndOfFileToken>;
2116        fileName: string;
2117        text: string;
2118        amdDependencies: readonly AmdDependency[];
2119        moduleName?: string;
2120        referencedFiles: readonly FileReference[];
2121        typeReferenceDirectives: readonly FileReference[];
2122        libReferenceDirectives: readonly FileReference[];
2123        languageVariant: LanguageVariant;
2124        isDeclarationFile: boolean;
2125        /**
2126         * lib.d.ts should have a reference comment like
2127         *
2128         *  /// <reference no-default-lib="true"/>
2129         *
2130         * If any other file has this comment, it signals not to include lib.d.ts
2131         * because this containing file is intended to act as a default library.
2132         */
2133        hasNoDefaultLib: boolean;
2134        languageVersion: ScriptTarget;
2135        /**
2136         * When `module` is `Node16` or `NodeNext`, this field controls whether the
2137         * source file in question is an ESNext-output-format file, or a CommonJS-output-format
2138         * module. This is derived by the module resolver as it looks up the file, since
2139         * it is derived from either the file extension of the module, or the containing
2140         * `package.json` context, and affects both checking and emit.
2141         *
2142         * It is _public_ so that (pre)transformers can set this field,
2143         * since it switches the builtin `node` module transform. Generally speaking, if unset,
2144         * the field is treated as though it is `ModuleKind.CommonJS`.
2145         *
2146         * Note that this field is only set by the module resolution process when
2147         * `moduleResolution` is `Node16` or `NodeNext`, which is implied by the `module` setting
2148         * of `Node16` or `NodeNext`, respectively, but may be overriden (eg, by a `moduleResolution`
2149         * of `node`). If so, this field will be unset and source files will be considered to be
2150         * CommonJS-output-format by the node module transformer and type checker, regardless of extension or context.
2151         */
2152        impliedNodeFormat?: ModuleKind.ESNext | ModuleKind.CommonJS;
2153    }
2154    export interface Bundle extends Node {
2155        readonly kind: SyntaxKind.Bundle;
2156        readonly prepends: readonly (InputFiles | UnparsedSource)[];
2157        readonly sourceFiles: readonly SourceFile[];
2158    }
2159    export interface InputFiles extends Node {
2160        readonly kind: SyntaxKind.InputFiles;
2161        javascriptPath?: string;
2162        javascriptText: string;
2163        javascriptMapPath?: string;
2164        javascriptMapText?: string;
2165        declarationPath?: string;
2166        declarationText: string;
2167        declarationMapPath?: string;
2168        declarationMapText?: string;
2169    }
2170    export interface UnparsedSource extends Node {
2171        readonly kind: SyntaxKind.UnparsedSource;
2172        fileName: string;
2173        text: string;
2174        readonly prologues: readonly UnparsedPrologue[];
2175        helpers: readonly UnscopedEmitHelper[] | undefined;
2176        referencedFiles: readonly FileReference[];
2177        typeReferenceDirectives: readonly FileReference[] | undefined;
2178        libReferenceDirectives: readonly FileReference[];
2179        hasNoDefaultLib?: boolean;
2180        sourceMapPath?: string;
2181        sourceMapText?: string;
2182        readonly syntheticReferences?: readonly UnparsedSyntheticReference[];
2183        readonly texts: readonly UnparsedSourceText[];
2184    }
2185    export type UnparsedSourceText = UnparsedPrepend | UnparsedTextLike;
2186    export type UnparsedNode = UnparsedPrologue | UnparsedSourceText | UnparsedSyntheticReference;
2187    export interface UnparsedSection extends Node {
2188        readonly kind: SyntaxKind;
2189        readonly parent: UnparsedSource;
2190        readonly data?: string;
2191    }
2192    export interface UnparsedPrologue extends UnparsedSection {
2193        readonly kind: SyntaxKind.UnparsedPrologue;
2194        readonly parent: UnparsedSource;
2195        readonly data: string;
2196    }
2197    export interface UnparsedPrepend extends UnparsedSection {
2198        readonly kind: SyntaxKind.UnparsedPrepend;
2199        readonly parent: UnparsedSource;
2200        readonly data: string;
2201        readonly texts: readonly UnparsedTextLike[];
2202    }
2203    export interface UnparsedTextLike extends UnparsedSection {
2204        readonly kind: SyntaxKind.UnparsedText | SyntaxKind.UnparsedInternalText;
2205        readonly parent: UnparsedSource;
2206    }
2207    export interface UnparsedSyntheticReference extends UnparsedSection {
2208        readonly kind: SyntaxKind.UnparsedSyntheticReference;
2209        readonly parent: UnparsedSource;
2210    }
2211    export interface JsonSourceFile extends SourceFile {
2212        readonly statements: NodeArray<JsonObjectExpressionStatement>;
2213    }
2214    export interface TsConfigSourceFile extends JsonSourceFile {
2215        extendedSourceFiles?: string[];
2216    }
2217    export interface JsonMinusNumericLiteral extends PrefixUnaryExpression {
2218        readonly kind: SyntaxKind.PrefixUnaryExpression;
2219        readonly operator: SyntaxKind.MinusToken;
2220        readonly operand: NumericLiteral;
2221    }
2222    export type JsonObjectExpression = ObjectLiteralExpression | ArrayLiteralExpression | JsonMinusNumericLiteral | NumericLiteral | StringLiteral | BooleanLiteral | NullLiteral;
2223    export interface JsonObjectExpressionStatement extends ExpressionStatement {
2224        readonly expression: JsonObjectExpression;
2225    }
2226    export interface ScriptReferenceHost {
2227        getCompilerOptions(): CompilerOptions;
2228        getSourceFile(fileName: string): SourceFile | undefined;
2229        getSourceFileByPath(path: Path): SourceFile | undefined;
2230        getCurrentDirectory(): string;
2231    }
2232    export interface ParseConfigHost {
2233        useCaseSensitiveFileNames: boolean;
2234        readDirectory(rootDir: string, extensions: readonly string[], excludes: readonly string[] | undefined, includes: readonly string[], depth?: number): readonly string[];
2235        /**
2236         * Gets a value indicating whether the specified path exists and is a file.
2237         * @param path The path to test.
2238         */
2239        fileExists(path: string): boolean;
2240        readFile(path: string): string | undefined;
2241        trace?(s: string): void;
2242    }
2243    /**
2244     * Branded string for keeping track of when we've turned an ambiguous path
2245     * specified like "./blah" to an absolute path to an actual
2246     * tsconfig file, e.g. "/root/blah/tsconfig.json"
2247     */
2248    export type ResolvedConfigFileName = string & {
2249        _isResolvedConfigFileName: never;
2250    };
2251    export interface WriteFileCallbackData {
2252    }
2253    export type WriteFileCallback = (fileName: string, text: string, writeByteOrderMark: boolean, onError?: (message: string) => void, sourceFiles?: readonly SourceFile[], data?: WriteFileCallbackData) => void;
2254    export class OperationCanceledException {
2255    }
2256    export interface CancellationToken {
2257        isCancellationRequested(): boolean;
2258        /** @throws OperationCanceledException if isCancellationRequested is true */
2259        throwIfCancellationRequested(): void;
2260    }
2261    export interface SymbolDisplayPart {
2262        text: string;
2263        kind: string;
2264    }
2265    export interface JsDocTagInfo {
2266        name: string;
2267        text?: string | SymbolDisplayPart[];
2268    }
2269    export interface Program extends ScriptReferenceHost {
2270        getCurrentDirectory(): string;
2271        /**
2272         * Get a list of root file names that were passed to a 'createProgram'
2273         */
2274        getRootFileNames(): readonly string[];
2275        /**
2276         * Get a list of files in the program
2277         */
2278        getSourceFiles(): readonly SourceFile[];
2279        /**
2280         * Emits the JavaScript and declaration files.  If targetSourceFile is not specified, then
2281         * the JavaScript and declaration files will be produced for all the files in this program.
2282         * If targetSourceFile is specified, then only the JavaScript and declaration for that
2283         * specific file will be generated.
2284         *
2285         * If writeFile is not specified then the writeFile callback from the compiler host will be
2286         * used for writing the JavaScript and declaration files.  Otherwise, the writeFile parameter
2287         * will be invoked when writing the JavaScript and declaration files.
2288         */
2289        emit(targetSourceFile?: SourceFile, writeFile?: WriteFileCallback, cancellationToken?: CancellationToken, emitOnlyDtsFiles?: boolean, customTransformers?: CustomTransformers): EmitResult;
2290        getOptionsDiagnostics(cancellationToken?: CancellationToken): readonly Diagnostic[];
2291        getGlobalDiagnostics(cancellationToken?: CancellationToken): readonly Diagnostic[];
2292        getSyntacticDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly DiagnosticWithLocation[];
2293        /** The first time this is called, it will return global diagnostics (no location). */
2294        getSemanticDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly Diagnostic[];
2295        getDeclarationDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly DiagnosticWithLocation[];
2296        getConfigFileParsingDiagnostics(): readonly Diagnostic[];
2297        getEtsLibSFromProgram(): string[];
2298        /**
2299         * Gets a type checker that can be used to semantically analyze source files in the program.
2300         */
2301        getTypeChecker(): TypeChecker;
2302        getNodeCount(): number;
2303        getIdentifierCount(): number;
2304        getSymbolCount(): number;
2305        getTypeCount(): number;
2306        getInstantiationCount(): number;
2307        getRelationCacheSizes(): {
2308            assignable: number;
2309            identity: number;
2310            subtype: number;
2311            strictSubtype: number;
2312        };
2313        isSourceFileFromExternalLibrary(file: SourceFile): boolean;
2314        isSourceFileDefaultLibrary(file: SourceFile): boolean;
2315        getSourceFileFromReference(referencingFile: SourceFile | UnparsedSource, ref: FileReference): SourceFile | undefined;
2316        getProjectReferences(): readonly ProjectReference[] | undefined;
2317        getResolvedProjectReferences(): readonly (ResolvedProjectReference | undefined)[] | undefined;
2318        getJsDocNodeCheckedConfig?(jsDocFileCheckInfo: FileCheckModuleInfo, symbolSourceFilePath: string): JsDocNodeCheckConfig;
2319        getJsDocNodeConditionCheckedResult?(jsDocFileCheckedInfo: FileCheckModuleInfo, jsDocs: JsDocTagInfo[]): ConditionCheckResult;
2320        getFileCheckedModuleInfo?(containFilePath: string): FileCheckModuleInfo;
2321    }
2322    export type RedirectTargetsMap = ReadonlyESMap<Path, readonly string[]>;
2323    export interface ResolvedProjectReference {
2324        commandLine: ParsedCommandLine;
2325        sourceFile: SourceFile;
2326        references?: readonly (ResolvedProjectReference | undefined)[];
2327    }
2328    export type CustomTransformerFactory = (context: TransformationContext) => CustomTransformer;
2329    export interface CustomTransformer {
2330        transformSourceFile(node: SourceFile): SourceFile;
2331        transformBundle(node: Bundle): Bundle;
2332    }
2333    export interface CustomTransformers {
2334        /** Custom transformers to evaluate before built-in .js transformations. */
2335        before?: (TransformerFactory<SourceFile> | CustomTransformerFactory)[];
2336        /** Custom transformers to evaluate after built-in .js transformations. */
2337        after?: (TransformerFactory<SourceFile> | CustomTransformerFactory)[];
2338        /** Custom transformers to evaluate after built-in .d.ts transformations. */
2339        afterDeclarations?: (TransformerFactory<Bundle | SourceFile> | CustomTransformerFactory)[];
2340    }
2341    export interface SourceMapSpan {
2342        /** Line number in the .js file. */
2343        emittedLine: number;
2344        /** Column number in the .js file. */
2345        emittedColumn: number;
2346        /** Line number in the .ts file. */
2347        sourceLine: number;
2348        /** Column number in the .ts file. */
2349        sourceColumn: number;
2350        /** Optional name (index into names array) associated with this span. */
2351        nameIndex?: number;
2352        /** .ts file (index into sources array) associated with this span */
2353        sourceIndex: number;
2354    }
2355    /** Return code used by getEmitOutput function to indicate status of the function */
2356    export enum ExitStatus {
2357        Success = 0,
2358        DiagnosticsPresent_OutputsSkipped = 1,
2359        DiagnosticsPresent_OutputsGenerated = 2,
2360        InvalidProject_OutputsSkipped = 3,
2361        ProjectReferenceCycle_OutputsSkipped = 4,
2362        /** @deprecated Use ProjectReferenceCycle_OutputsSkipped instead. */
2363        ProjectReferenceCycle_OutputsSkupped = 4
2364    }
2365    export interface EmitResult {
2366        emitSkipped: boolean;
2367        /** Contains declaration emit diagnostics */
2368        diagnostics: readonly Diagnostic[];
2369        emittedFiles?: string[];
2370    }
2371    export interface TypeChecker {
2372        getTypeOfSymbolAtLocation(symbol: Symbol, node: Node): Type;
2373        getDeclaredTypeOfSymbol(symbol: Symbol): Type;
2374        getPropertiesOfType(type: Type): Symbol[];
2375        getPropertyOfType(type: Type, propertyName: string): Symbol | undefined;
2376        getPrivateIdentifierPropertyOfType(leftType: Type, name: string, location: Node): Symbol | undefined;
2377        getIndexInfoOfType(type: Type, kind: IndexKind): IndexInfo | undefined;
2378        getIndexInfosOfType(type: Type): readonly IndexInfo[];
2379        getIndexInfosOfIndexSymbol: (indexSymbol: Symbol) => IndexInfo[];
2380        getSignaturesOfType(type: Type, kind: SignatureKind): readonly Signature[];
2381        getIndexTypeOfType(type: Type, kind: IndexKind): Type | undefined;
2382        getBaseTypes(type: InterfaceType): BaseType[];
2383        getBaseTypeOfLiteralType(type: Type): Type;
2384        getWidenedType(type: Type): Type;
2385        getReturnTypeOfSignature(signature: Signature): Type;
2386        getNullableType(type: Type, flags: TypeFlags): Type;
2387        getNonNullableType(type: Type): Type;
2388        getTypeArguments(type: TypeReference): readonly Type[];
2389        /** Note that the resulting nodes cannot be checked. */
2390        typeToTypeNode(type: Type, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): TypeNode | undefined;
2391        /** Note that the resulting nodes cannot be checked. */
2392        signatureToSignatureDeclaration(signature: Signature, kind: SyntaxKind, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): SignatureDeclaration & {
2393            typeArguments?: NodeArray<TypeNode>;
2394        } | undefined;
2395        /** Note that the resulting nodes cannot be checked. */
2396        indexInfoToIndexSignatureDeclaration(indexInfo: IndexInfo, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): IndexSignatureDeclaration | undefined;
2397        /** Note that the resulting nodes cannot be checked. */
2398        symbolToEntityName(symbol: Symbol, meaning: SymbolFlags, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): EntityName | undefined;
2399        /** Note that the resulting nodes cannot be checked. */
2400        symbolToExpression(symbol: Symbol, meaning: SymbolFlags, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): Expression | undefined;
2401        /** Note that the resulting nodes cannot be checked. */
2402        symbolToTypeParameterDeclarations(symbol: Symbol, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): NodeArray<TypeParameterDeclaration> | undefined;
2403        /** Note that the resulting nodes cannot be checked. */
2404        symbolToParameterDeclaration(symbol: Symbol, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): ParameterDeclaration | undefined;
2405        /** Note that the resulting nodes cannot be checked. */
2406        typeParameterToDeclaration(parameter: TypeParameter, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): TypeParameterDeclaration | undefined;
2407        getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[];
2408        getSymbolAtLocation(node: Node): Symbol | undefined;
2409        getSymbolsOfParameterPropertyDeclaration(parameter: ParameterDeclaration, parameterName: string): Symbol[];
2410        /**
2411         * The function returns the value (local variable) symbol of an identifier in the short-hand property assignment.
2412         * This is necessary as an identifier in short-hand property assignment can contains two meaning: property name and property value.
2413         */
2414        getShorthandAssignmentValueSymbol(location: Node | undefined): Symbol | undefined;
2415        getExportSpecifierLocalTargetSymbol(location: ExportSpecifier | Identifier): Symbol | undefined;
2416        /**
2417         * If a symbol is a local symbol with an associated exported symbol, returns the exported symbol.
2418         * Otherwise returns its input.
2419         * For example, at `export type T = number;`:
2420         *     - `getSymbolAtLocation` at the location `T` will return the exported symbol for `T`.
2421         *     - But the result of `getSymbolsInScope` will contain the *local* symbol for `T`, not the exported symbol.
2422         *     - Calling `getExportSymbolOfSymbol` on that local symbol will return the exported symbol.
2423         */
2424        getExportSymbolOfSymbol(symbol: Symbol): Symbol;
2425        getPropertySymbolOfDestructuringAssignment(location: Identifier): Symbol | undefined;
2426        getTypeOfAssignmentPattern(pattern: AssignmentPattern): Type;
2427        getTypeAtLocation(node: Node): Type;
2428        tryGetTypeAtLocationWithoutCheck(node: Node): Type;
2429        getTypeFromTypeNode(node: TypeNode): Type;
2430        signatureToString(signature: Signature, enclosingDeclaration?: Node, flags?: TypeFormatFlags, kind?: SignatureKind): string;
2431        typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string;
2432        symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags): string;
2433        typePredicateToString(predicate: TypePredicate, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string;
2434        getFullyQualifiedName(symbol: Symbol): string;
2435        getAugmentedPropertiesOfType(type: Type): Symbol[];
2436        getRootSymbols(symbol: Symbol): readonly Symbol[];
2437        getSymbolOfExpando(node: Node, allowDeclaration: boolean): Symbol | undefined;
2438        getContextualType(node: Expression): Type | undefined;
2439        /**
2440         * returns unknownSignature in the case of an error.
2441         * returns undefined if the node is not valid.
2442         * @param argumentCount Apparent number of arguments, passed in case of a possibly incomplete call. This should come from an ArgumentListInfo. See `signatureHelp.ts`.
2443         */
2444        getResolvedSignature(node: CallLikeExpression, candidatesOutArray?: Signature[], argumentCount?: number): Signature | undefined;
2445        tryGetResolvedSignatureWithoutCheck(node: CallLikeExpression, candidatesOutArray?: Signature[], argumentCount?: number): Signature | undefined;
2446        getSignatureFromDeclaration(declaration: SignatureDeclaration): Signature | undefined;
2447        isImplementationOfOverload(node: SignatureDeclaration): boolean | undefined;
2448        isUndefinedSymbol(symbol: Symbol): boolean;
2449        isArgumentsSymbol(symbol: Symbol): boolean;
2450        isUnknownSymbol(symbol: Symbol): boolean;
2451        getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): string | number | undefined;
2452        isValidPropertyAccess(node: PropertyAccessExpression | QualifiedName | ImportTypeNode, propertyName: string): boolean;
2453        /** Follow all aliases to get the original symbol. */
2454        getAliasedSymbol(symbol: Symbol): Symbol;
2455        /** Follow a *single* alias to get the immediately aliased symbol. */
2456        getImmediateAliasedSymbol(symbol: Symbol): Symbol | undefined;
2457        getExportsOfModule(moduleSymbol: Symbol): Symbol[];
2458        getJsxIntrinsicTagNamesAt(location: Node): Symbol[];
2459        isOptionalParameter(node: ParameterDeclaration): boolean;
2460        getAmbientModules(): Symbol[];
2461        tryGetMemberInModuleExports(memberName: string, moduleSymbol: Symbol): Symbol | undefined;
2462        getApparentType(type: Type): Type;
2463        getBaseConstraintOfType(type: Type): Type | undefined;
2464        getDefaultFromTypeParameter(type: Type): Type | undefined;
2465        getTypePredicateOfSignature(signature: Signature): TypePredicate | undefined;
2466        /**
2467         * Depending on the operation performed, it may be appropriate to throw away the checker
2468         * if the cancellation token is triggered. Typically, if it is used for error checking
2469         * and the operation is cancelled, then it should be discarded, otherwise it is safe to keep.
2470         */
2471        runWithCancellationToken<T>(token: CancellationToken, cb: (checker: TypeChecker) => T): T;
2472    }
2473    export enum NodeBuilderFlags {
2474        None = 0,
2475        NoTruncation = 1,
2476        WriteArrayAsGenericType = 2,
2477        GenerateNamesForShadowedTypeParams = 4,
2478        UseStructuralFallback = 8,
2479        ForbidIndexedAccessSymbolReferences = 16,
2480        WriteTypeArgumentsOfSignature = 32,
2481        UseFullyQualifiedType = 64,
2482        UseOnlyExternalAliasing = 128,
2483        SuppressAnyReturnType = 256,
2484        WriteTypeParametersInQualifiedName = 512,
2485        MultilineObjectLiterals = 1024,
2486        WriteClassExpressionAsTypeLiteral = 2048,
2487        UseTypeOfFunction = 4096,
2488        OmitParameterModifiers = 8192,
2489        UseAliasDefinedOutsideCurrentScope = 16384,
2490        UseSingleQuotesForStringLiteralType = 268435456,
2491        NoTypeReduction = 536870912,
2492        OmitThisParameter = 33554432,
2493        AllowThisInObjectLiteral = 32768,
2494        AllowQualifiedNameInPlaceOfIdentifier = 65536,
2495        /** @deprecated AllowQualifedNameInPlaceOfIdentifier. Use AllowQualifiedNameInPlaceOfIdentifier instead. */
2496        AllowQualifedNameInPlaceOfIdentifier = 65536,
2497        AllowAnonymousIdentifier = 131072,
2498        AllowEmptyUnionOrIntersection = 262144,
2499        AllowEmptyTuple = 524288,
2500        AllowUniqueESSymbolType = 1048576,
2501        AllowEmptyIndexInfoType = 2097152,
2502        AllowNodeModulesRelativePaths = 67108864,
2503        IgnoreErrors = 70221824,
2504        InObjectTypeLiteral = 4194304,
2505        InTypeAlias = 8388608,
2506        InInitialEntityName = 16777216
2507    }
2508    export enum TypeFormatFlags {
2509        None = 0,
2510        NoTruncation = 1,
2511        WriteArrayAsGenericType = 2,
2512        UseStructuralFallback = 8,
2513        WriteTypeArgumentsOfSignature = 32,
2514        UseFullyQualifiedType = 64,
2515        SuppressAnyReturnType = 256,
2516        MultilineObjectLiterals = 1024,
2517        WriteClassExpressionAsTypeLiteral = 2048,
2518        UseTypeOfFunction = 4096,
2519        OmitParameterModifiers = 8192,
2520        UseAliasDefinedOutsideCurrentScope = 16384,
2521        UseSingleQuotesForStringLiteralType = 268435456,
2522        NoTypeReduction = 536870912,
2523        OmitThisParameter = 33554432,
2524        AllowUniqueESSymbolType = 1048576,
2525        AddUndefined = 131072,
2526        WriteArrowStyleSignature = 262144,
2527        InArrayType = 524288,
2528        InElementType = 2097152,
2529        InFirstTypeArgument = 4194304,
2530        InTypeAlias = 8388608,
2531        /** @deprecated */ WriteOwnNameForAnyLike = 0,
2532        NodeBuilderFlagsMask = 848330091
2533    }
2534    export enum SymbolFormatFlags {
2535        None = 0,
2536        WriteTypeParametersOrArguments = 1,
2537        UseOnlyExternalAliasing = 2,
2538        AllowAnyNodeKind = 4,
2539        UseAliasDefinedOutsideCurrentScope = 8,
2540    }
2541    interface SymbolWriter extends SymbolTracker {
2542        writeKeyword(text: string): void;
2543        writeOperator(text: string): void;
2544        writePunctuation(text: string): void;
2545        writeSpace(text: string): void;
2546        writeStringLiteral(text: string): void;
2547        writeParameter(text: string): void;
2548        writeProperty(text: string): void;
2549        writeSymbol(text: string, symbol: Symbol): void;
2550        writeLine(force?: boolean): void;
2551        increaseIndent(): void;
2552        decreaseIndent(): void;
2553        clear(): void;
2554    }
2555    export enum TypePredicateKind {
2556        This = 0,
2557        Identifier = 1,
2558        AssertsThis = 2,
2559        AssertsIdentifier = 3
2560    }
2561    export interface TypePredicateBase {
2562        kind: TypePredicateKind;
2563        type: Type | undefined;
2564    }
2565    export interface ThisTypePredicate extends TypePredicateBase {
2566        kind: TypePredicateKind.This;
2567        parameterName: undefined;
2568        parameterIndex: undefined;
2569        type: Type;
2570    }
2571    export interface IdentifierTypePredicate extends TypePredicateBase {
2572        kind: TypePredicateKind.Identifier;
2573        parameterName: string;
2574        parameterIndex: number;
2575        type: Type;
2576    }
2577    export interface AssertsThisTypePredicate extends TypePredicateBase {
2578        kind: TypePredicateKind.AssertsThis;
2579        parameterName: undefined;
2580        parameterIndex: undefined;
2581        type: Type | undefined;
2582    }
2583    export interface AssertsIdentifierTypePredicate extends TypePredicateBase {
2584        kind: TypePredicateKind.AssertsIdentifier;
2585        parameterName: string;
2586        parameterIndex: number;
2587        type: Type | undefined;
2588    }
2589    export type TypePredicate = ThisTypePredicate | IdentifierTypePredicate | AssertsThisTypePredicate | AssertsIdentifierTypePredicate;
2590    export enum SymbolFlags {
2591        None = 0,
2592        FunctionScopedVariable = 1,
2593        BlockScopedVariable = 2,
2594        Property = 4,
2595        EnumMember = 8,
2596        Function = 16,
2597        Class = 32,
2598        Interface = 64,
2599        ConstEnum = 128,
2600        RegularEnum = 256,
2601        ValueModule = 512,
2602        NamespaceModule = 1024,
2603        TypeLiteral = 2048,
2604        ObjectLiteral = 4096,
2605        Method = 8192,
2606        Constructor = 16384,
2607        GetAccessor = 32768,
2608        SetAccessor = 65536,
2609        Signature = 131072,
2610        TypeParameter = 262144,
2611        TypeAlias = 524288,
2612        ExportValue = 1048576,
2613        Alias = 2097152,
2614        Prototype = 4194304,
2615        ExportStar = 8388608,
2616        Optional = 16777216,
2617        Transient = 33554432,
2618        Assignment = 67108864,
2619        ModuleExports = 134217728,
2620        Enum = 384,
2621        Variable = 3,
2622        Value = 111551,
2623        Type = 788968,
2624        Namespace = 1920,
2625        Module = 1536,
2626        Accessor = 98304,
2627        FunctionScopedVariableExcludes = 111550,
2628        BlockScopedVariableExcludes = 111551,
2629        ParameterExcludes = 111551,
2630        PropertyExcludes = 0,
2631        EnumMemberExcludes = 900095,
2632        FunctionExcludes = 110991,
2633        ClassExcludes = 899503,
2634        InterfaceExcludes = 788872,
2635        RegularEnumExcludes = 899327,
2636        ConstEnumExcludes = 899967,
2637        ValueModuleExcludes = 110735,
2638        NamespaceModuleExcludes = 0,
2639        MethodExcludes = 103359,
2640        GetAccessorExcludes = 46015,
2641        SetAccessorExcludes = 78783,
2642        AccessorExcludes = 13247,
2643        TypeParameterExcludes = 526824,
2644        TypeAliasExcludes = 788968,
2645        AliasExcludes = 2097152,
2646        ModuleMember = 2623475,
2647        ExportHasLocal = 944,
2648        BlockScoped = 418,
2649        PropertyOrAccessor = 98308,
2650        ClassMember = 106500,
2651    }
2652    export interface Symbol {
2653        flags: SymbolFlags;
2654        escapedName: __String;
2655        declarations?: Declaration[];
2656        valueDeclaration?: Declaration;
2657        members?: SymbolTable;
2658        exports?: SymbolTable;
2659        globalExports?: SymbolTable;
2660        exportSymbol?: Symbol;
2661    }
2662    export enum InternalSymbolName {
2663        Call = "__call",
2664        Constructor = "__constructor",
2665        New = "__new",
2666        Index = "__index",
2667        ExportStar = "__export",
2668        Global = "__global",
2669        Missing = "__missing",
2670        Type = "__type",
2671        Object = "__object",
2672        JSXAttributes = "__jsxAttributes",
2673        Class = "__class",
2674        Function = "__function",
2675        Computed = "__computed",
2676        Resolving = "__resolving__",
2677        ExportEquals = "export=",
2678        Default = "default",
2679        This = "this"
2680    }
2681    /**
2682     * This represents a string whose leading underscore have been escaped by adding extra leading underscores.
2683     * The shape of this brand is rather unique compared to others we've used.
2684     * Instead of just an intersection of a string and an object, it is that union-ed
2685     * with an intersection of void and an object. This makes it wholly incompatible
2686     * with a normal string (which is good, it cannot be misused on assignment or on usage),
2687     * while still being comparable with a normal string via === (also good) and castable from a string.
2688     */
2689    export type __String = (string & {
2690        __escapedIdentifier: void;
2691    }) | (void & {
2692        __escapedIdentifier: void;
2693    }) | InternalSymbolName;
2694    /** ReadonlyMap where keys are `__String`s. */
2695    export interface ReadonlyUnderscoreEscapedMap<T> extends ReadonlyESMap<__String, T> {
2696    }
2697    /** Map where keys are `__String`s. */
2698    export interface UnderscoreEscapedMap<T> extends ESMap<__String, T>, ReadonlyUnderscoreEscapedMap<T> {
2699    }
2700    /** SymbolTable based on ES6 Map interface. */
2701    export type SymbolTable = UnderscoreEscapedMap<Symbol>;
2702    export enum TypeFlags {
2703        Any = 1,
2704        Unknown = 2,
2705        String = 4,
2706        Number = 8,
2707        Boolean = 16,
2708        Enum = 32,
2709        BigInt = 64,
2710        StringLiteral = 128,
2711        NumberLiteral = 256,
2712        BooleanLiteral = 512,
2713        EnumLiteral = 1024,
2714        BigIntLiteral = 2048,
2715        ESSymbol = 4096,
2716        UniqueESSymbol = 8192,
2717        Void = 16384,
2718        Undefined = 32768,
2719        Null = 65536,
2720        Never = 131072,
2721        TypeParameter = 262144,
2722        Object = 524288,
2723        Union = 1048576,
2724        Intersection = 2097152,
2725        Index = 4194304,
2726        IndexedAccess = 8388608,
2727        Conditional = 16777216,
2728        Substitution = 33554432,
2729        NonPrimitive = 67108864,
2730        TemplateLiteral = 134217728,
2731        StringMapping = 268435456,
2732        Literal = 2944,
2733        Unit = 109440,
2734        StringOrNumberLiteral = 384,
2735        PossiblyFalsy = 117724,
2736        StringLike = 402653316,
2737        NumberLike = 296,
2738        BigIntLike = 2112,
2739        BooleanLike = 528,
2740        EnumLike = 1056,
2741        ESSymbolLike = 12288,
2742        VoidLike = 49152,
2743        UnionOrIntersection = 3145728,
2744        StructuredType = 3670016,
2745        TypeVariable = 8650752,
2746        InstantiableNonPrimitive = 58982400,
2747        InstantiablePrimitive = 406847488,
2748        Instantiable = 465829888,
2749        StructuredOrInstantiable = 469499904,
2750        Narrowable = 536624127,
2751    }
2752    export type DestructuringPattern = BindingPattern | ObjectLiteralExpression | ArrayLiteralExpression;
2753    export interface Type {
2754        flags: TypeFlags;
2755        symbol: Symbol;
2756        pattern?: DestructuringPattern;
2757        aliasSymbol?: Symbol;
2758        aliasTypeArguments?: readonly Type[];
2759    }
2760    export interface LiteralType extends Type {
2761        value: string | number | PseudoBigInt;
2762        freshType: LiteralType;
2763        regularType: LiteralType;
2764    }
2765    export interface UniqueESSymbolType extends Type {
2766        symbol: Symbol;
2767        escapedName: __String;
2768    }
2769    export interface StringLiteralType extends LiteralType {
2770        value: string;
2771    }
2772    export interface NumberLiteralType extends LiteralType {
2773        value: number;
2774    }
2775    export interface BigIntLiteralType extends LiteralType {
2776        value: PseudoBigInt;
2777    }
2778    export interface EnumType extends Type {
2779    }
2780    export enum ObjectFlags {
2781        Class = 1,
2782        Interface = 2,
2783        Reference = 4,
2784        Tuple = 8,
2785        Anonymous = 16,
2786        Mapped = 32,
2787        Instantiated = 64,
2788        ObjectLiteral = 128,
2789        EvolvingArray = 256,
2790        ObjectLiteralPatternWithComputedProperties = 512,
2791        ReverseMapped = 1024,
2792        JsxAttributes = 2048,
2793        JSLiteral = 4096,
2794        FreshLiteral = 8192,
2795        ArrayLiteral = 16384,
2796        ClassOrInterface = 3,
2797        ContainsSpread = 2097152,
2798        ObjectRestType = 4194304,
2799        InstantiationExpressionType = 8388608,
2800    }
2801    export interface ObjectType extends Type {
2802        objectFlags: ObjectFlags;
2803    }
2804    /** Class and interface types (ObjectFlags.Class and ObjectFlags.Interface). */
2805    export interface InterfaceType extends ObjectType {
2806        typeParameters: TypeParameter[] | undefined;
2807        outerTypeParameters: TypeParameter[] | undefined;
2808        localTypeParameters: TypeParameter[] | undefined;
2809        thisType: TypeParameter | undefined;
2810    }
2811    export type BaseType = ObjectType | IntersectionType | TypeVariable;
2812    export interface InterfaceTypeWithDeclaredMembers extends InterfaceType {
2813        declaredProperties: Symbol[];
2814        declaredCallSignatures: Signature[];
2815        declaredConstructSignatures: Signature[];
2816        declaredIndexInfos: IndexInfo[];
2817    }
2818    /**
2819     * Type references (ObjectFlags.Reference). When a class or interface has type parameters or
2820     * a "this" type, references to the class or interface are made using type references. The
2821     * typeArguments property specifies the types to substitute for the type parameters of the
2822     * class or interface and optionally includes an extra element that specifies the type to
2823     * substitute for "this" in the resulting instantiation. When no extra argument is present,
2824     * the type reference itself is substituted for "this". The typeArguments property is undefined
2825     * if the class or interface has no type parameters and the reference isn't specifying an
2826     * explicit "this" argument.
2827     */
2828    export interface TypeReference extends ObjectType {
2829        target: GenericType;
2830        node?: TypeReferenceNode | ArrayTypeNode | TupleTypeNode;
2831    }
2832    export interface DeferredTypeReference extends TypeReference {
2833    }
2834    export interface GenericType extends InterfaceType, TypeReference {
2835    }
2836    export enum ElementFlags {
2837        Required = 1,
2838        Optional = 2,
2839        Rest = 4,
2840        Variadic = 8,
2841        Fixed = 3,
2842        Variable = 12,
2843        NonRequired = 14,
2844        NonRest = 11
2845    }
2846    export interface TupleType extends GenericType {
2847        elementFlags: readonly ElementFlags[];
2848        minLength: number;
2849        fixedLength: number;
2850        hasRestElement: boolean;
2851        combinedFlags: ElementFlags;
2852        readonly: boolean;
2853        labeledElementDeclarations?: readonly (NamedTupleMember | ParameterDeclaration)[];
2854    }
2855    export interface TupleTypeReference extends TypeReference {
2856        target: TupleType;
2857    }
2858    export interface UnionOrIntersectionType extends Type {
2859        types: Type[];
2860    }
2861    export interface UnionType extends UnionOrIntersectionType {
2862    }
2863    export interface IntersectionType extends UnionOrIntersectionType {
2864    }
2865    export type StructuredType = ObjectType | UnionType | IntersectionType;
2866    export interface EvolvingArrayType extends ObjectType {
2867        elementType: Type;
2868        finalArrayType?: Type;
2869    }
2870    export interface InstantiableType extends Type {
2871    }
2872    export interface TypeParameter extends InstantiableType {
2873    }
2874    export interface IndexedAccessType extends InstantiableType {
2875        objectType: Type;
2876        indexType: Type;
2877        constraint?: Type;
2878        simplifiedForReading?: Type;
2879        simplifiedForWriting?: Type;
2880    }
2881    export type TypeVariable = TypeParameter | IndexedAccessType;
2882    export interface IndexType extends InstantiableType {
2883        type: InstantiableType | UnionOrIntersectionType;
2884    }
2885    export interface ConditionalRoot {
2886        node: ConditionalTypeNode;
2887        checkType: Type;
2888        extendsType: Type;
2889        isDistributive: boolean;
2890        inferTypeParameters?: TypeParameter[];
2891        outerTypeParameters?: TypeParameter[];
2892        instantiations?: Map<Type>;
2893        aliasSymbol?: Symbol;
2894        aliasTypeArguments?: Type[];
2895    }
2896    export interface ConditionalType extends InstantiableType {
2897        root: ConditionalRoot;
2898        checkType: Type;
2899        extendsType: Type;
2900        resolvedTrueType?: Type;
2901        resolvedFalseType?: Type;
2902    }
2903    export interface TemplateLiteralType extends InstantiableType {
2904        texts: readonly string[];
2905        types: readonly Type[];
2906    }
2907    export interface StringMappingType extends InstantiableType {
2908        symbol: Symbol;
2909        type: Type;
2910    }
2911    export interface SubstitutionType extends InstantiableType {
2912        objectFlags: ObjectFlags;
2913        baseType: Type;
2914        constraint: Type;
2915    }
2916    export enum SignatureKind {
2917        Call = 0,
2918        Construct = 1
2919    }
2920    export interface Signature {
2921        declaration?: SignatureDeclaration | JSDocSignature;
2922        typeParameters?: readonly TypeParameter[];
2923        parameters: readonly Symbol[];
2924    }
2925    export enum IndexKind {
2926        String = 0,
2927        Number = 1
2928    }
2929    export interface IndexInfo {
2930        keyType: Type;
2931        type: Type;
2932        isReadonly: boolean;
2933        declaration?: IndexSignatureDeclaration;
2934    }
2935    export enum InferencePriority {
2936        NakedTypeVariable = 1,
2937        SpeculativeTuple = 2,
2938        SubstituteSource = 4,
2939        HomomorphicMappedType = 8,
2940        PartialHomomorphicMappedType = 16,
2941        MappedTypeConstraint = 32,
2942        ContravariantConditional = 64,
2943        ReturnType = 128,
2944        LiteralKeyof = 256,
2945        NoConstraints = 512,
2946        AlwaysStrict = 1024,
2947        MaxValue = 2048,
2948        PriorityImpliesCombination = 416,
2949        Circularity = -1
2950    }
2951    /** @deprecated Use FileExtensionInfo instead. */
2952    export type JsFileExtensionInfo = FileExtensionInfo;
2953    export interface FileExtensionInfo {
2954        extension: string;
2955        isMixedContent: boolean;
2956        scriptKind?: ScriptKind;
2957    }
2958    export interface DiagnosticMessage {
2959        key: string;
2960        category: DiagnosticCategory;
2961        code: number;
2962        message: string;
2963        reportsUnnecessary?: {};
2964        reportsDeprecated?: {};
2965    }
2966    /**
2967     * A linked list of formatted diagnostic messages to be used as part of a multiline message.
2968     * It is built from the bottom up, leaving the head to be the "main" diagnostic.
2969     * While it seems that DiagnosticMessageChain is structurally similar to DiagnosticMessage,
2970     * the difference is that messages are all preformatted in DMC.
2971     */
2972    export interface DiagnosticMessageChain {
2973        messageText: string;
2974        category: DiagnosticCategory;
2975        code: number;
2976        next?: DiagnosticMessageChain[];
2977    }
2978    export interface Diagnostic extends DiagnosticRelatedInformation {
2979        /** May store more in future. For now, this will simply be `true` to indicate when a diagnostic is an unused-identifier diagnostic. */
2980        reportsUnnecessary?: {};
2981        reportsDeprecated?: {};
2982        source?: string;
2983        relatedInformation?: DiagnosticRelatedInformation[];
2984    }
2985    export interface DiagnosticRelatedInformation {
2986        category: DiagnosticCategory;
2987        code: number;
2988        file: SourceFile | undefined;
2989        start: number | undefined;
2990        length: number | undefined;
2991        messageText: string | DiagnosticMessageChain;
2992    }
2993    export interface DiagnosticWithLocation extends Diagnostic {
2994        file: SourceFile;
2995        start: number;
2996        length: number;
2997    }
2998    export enum DiagnosticCategory {
2999        Warning = 0,
3000        Error = 1,
3001        Suggestion = 2,
3002        Message = 3
3003    }
3004    export enum ModuleResolutionKind {
3005        Classic = 1,
3006        NodeJs = 2,
3007        Node16 = 3,
3008        NodeNext = 99
3009    }
3010    export enum ModuleDetectionKind {
3011        /**
3012         * Files with imports, exports and/or import.meta are considered modules
3013         */
3014        Legacy = 1,
3015        /**
3016         * Legacy, but also files with jsx under react-jsx or react-jsxdev and esm mode files under moduleResolution: node16+
3017         */
3018        Auto = 2,
3019        /**
3020         * Consider all non-declaration files modules, regardless of present syntax
3021         */
3022        Force = 3
3023    }
3024    export interface PluginImport {
3025        name: string;
3026    }
3027    export interface ProjectReference {
3028        /** A normalized path on disk */
3029        path: string;
3030        /** The path as the user originally wrote it */
3031        originalPath?: string;
3032        /** True if the output of this reference should be prepended to the output of this project. Only valid for --outFile compilations */
3033        prepend?: boolean;
3034        /** True if it is intended that this reference form a circularity */
3035        circular?: boolean;
3036    }
3037    export enum WatchFileKind {
3038        FixedPollingInterval = 0,
3039        PriorityPollingInterval = 1,
3040        DynamicPriorityPolling = 2,
3041        FixedChunkSizePolling = 3,
3042        UseFsEvents = 4,
3043        UseFsEventsOnParentDirectory = 5
3044    }
3045    export enum WatchDirectoryKind {
3046        UseFsEvents = 0,
3047        FixedPollingInterval = 1,
3048        DynamicPriorityPolling = 2,
3049        FixedChunkSizePolling = 3
3050    }
3051    export enum PollingWatchKind {
3052        FixedInterval = 0,
3053        PriorityInterval = 1,
3054        DynamicPriority = 2,
3055        FixedChunkSize = 3
3056    }
3057    export type CompilerOptionsValue = string | number | boolean | (string | number)[] | string[] | MapLike<string[]> | PluginImport[] | ProjectReference[] | null | undefined | EtsOptions;
3058    export interface CompilerOptions {
3059        allowJs?: boolean;
3060        allowSyntheticDefaultImports?: boolean;
3061        allowUmdGlobalAccess?: boolean;
3062        allowUnreachableCode?: boolean;
3063        allowUnusedLabels?: boolean;
3064        alwaysStrict?: boolean;
3065        baseUrl?: string;
3066        charset?: string;
3067        checkJs?: boolean;
3068        declaration?: boolean;
3069        declarationMap?: boolean;
3070        emitDeclarationOnly?: boolean;
3071        declarationDir?: string;
3072        disableSizeLimit?: boolean;
3073        disableSourceOfProjectReferenceRedirect?: boolean;
3074        disableSolutionSearching?: boolean;
3075        disableReferencedProjectLoad?: boolean;
3076        downlevelIteration?: boolean;
3077        emitBOM?: boolean;
3078        emitDecoratorMetadata?: boolean;
3079        exactOptionalPropertyTypes?: boolean;
3080        experimentalDecorators?: boolean;
3081        forceConsistentCasingInFileNames?: boolean;
3082        importHelpers?: boolean;
3083        importsNotUsedAsValues?: ImportsNotUsedAsValues;
3084        inlineSourceMap?: boolean;
3085        inlineSources?: boolean;
3086        isolatedModules?: boolean;
3087        jsx?: JsxEmit;
3088        keyofStringsOnly?: boolean;
3089        lib?: string[];
3090        locale?: string;
3091        mapRoot?: string;
3092        maxNodeModuleJsDepth?: number;
3093        module?: ModuleKind;
3094        moduleResolution?: ModuleResolutionKind;
3095        moduleSuffixes?: string[];
3096        moduleDetection?: ModuleDetectionKind;
3097        newLine?: NewLineKind;
3098        noEmit?: boolean;
3099        noEmitHelpers?: boolean;
3100        noEmitOnError?: boolean;
3101        noErrorTruncation?: boolean;
3102        noFallthroughCasesInSwitch?: boolean;
3103        noImplicitAny?: boolean;
3104        noImplicitReturns?: boolean;
3105        noImplicitThis?: boolean;
3106        noStrictGenericChecks?: boolean;
3107        noUnusedLocals?: boolean;
3108        noUnusedParameters?: boolean;
3109        noImplicitUseStrict?: boolean;
3110        noPropertyAccessFromIndexSignature?: boolean;
3111        assumeChangesOnlyAffectDirectDependencies?: boolean;
3112        noLib?: boolean;
3113        noResolve?: boolean;
3114        noUncheckedIndexedAccess?: boolean;
3115        out?: string;
3116        outDir?: string;
3117        outFile?: string;
3118        paths?: MapLike<string[]>;
3119        preserveConstEnums?: boolean;
3120        noImplicitOverride?: boolean;
3121        preserveSymlinks?: boolean;
3122        preserveValueImports?: boolean;
3123        project?: string;
3124        reactNamespace?: string;
3125        jsxFactory?: string;
3126        jsxFragmentFactory?: string;
3127        jsxImportSource?: string;
3128        composite?: boolean;
3129        incremental?: boolean;
3130        tsBuildInfoFile?: string;
3131        removeComments?: boolean;
3132        rootDir?: string;
3133        rootDirs?: string[];
3134        skipLibCheck?: boolean;
3135        skipDefaultLibCheck?: boolean;
3136        sourceMap?: boolean;
3137        sourceRoot?: string;
3138        strict?: boolean;
3139        strictFunctionTypes?: boolean;
3140        strictBindCallApply?: boolean;
3141        strictNullChecks?: boolean;
3142        strictPropertyInitialization?: boolean;
3143        stripInternal?: boolean;
3144        suppressExcessPropertyErrors?: boolean;
3145        suppressImplicitAnyIndexErrors?: boolean;
3146        target?: ScriptTarget;
3147        traceResolution?: boolean;
3148        useUnknownInCatchVariables?: boolean;
3149        resolveJsonModule?: boolean;
3150        types?: string[];
3151        /** Paths used to compute primary types search locations */
3152        typeRoots?: string[];
3153        esModuleInterop?: boolean;
3154        useDefineForClassFields?: boolean;
3155        ets?: EtsOptions;
3156        packageManagerType?: string;
3157        emitNodeModulesFiles?: boolean;
3158        etsLoaderPath?: string;
3159        [option: string]: CompilerOptionsValue | TsConfigSourceFile | undefined;
3160    }
3161    export interface EtsOptions {
3162        render: {
3163            method: string[];
3164            decorator: string;
3165        };
3166        components: string[];
3167        libs: string[];
3168        extend: {
3169            decorator: string[];
3170            components: {
3171                name: string;
3172                type: string;
3173                instance: string;
3174            }[];
3175        };
3176        styles: {
3177            decorator: string;
3178            component: {
3179                name: string;
3180                type: string;
3181                instance: string;
3182            };
3183            property: string;
3184        };
3185        concurrent: {
3186            decorator: string;
3187        };
3188        customComponent?: string;
3189        propertyDecorators: {
3190            name: string;
3191            needInitialization: boolean;
3192        }[];
3193        emitDecorators: {
3194            name: string;
3195            emitParameters: boolean;
3196        }[];
3197    }
3198    export interface WatchOptions {
3199        watchFile?: WatchFileKind;
3200        watchDirectory?: WatchDirectoryKind;
3201        fallbackPolling?: PollingWatchKind;
3202        synchronousWatchDirectory?: boolean;
3203        excludeDirectories?: string[];
3204        excludeFiles?: string[];
3205        [option: string]: CompilerOptionsValue | undefined;
3206    }
3207    export interface TypeAcquisition {
3208        /**
3209         * @deprecated typingOptions.enableAutoDiscovery
3210         * Use typeAcquisition.enable instead.
3211         */
3212        enableAutoDiscovery?: boolean;
3213        enable?: boolean;
3214        include?: string[];
3215        exclude?: string[];
3216        disableFilenameBasedTypeAcquisition?: boolean;
3217        [option: string]: CompilerOptionsValue | undefined;
3218    }
3219    export enum ModuleKind {
3220        None = 0,
3221        CommonJS = 1,
3222        AMD = 2,
3223        UMD = 3,
3224        System = 4,
3225        ES2015 = 5,
3226        ES2020 = 6,
3227        ES2022 = 7,
3228        ESNext = 99,
3229        Node16 = 100,
3230        NodeNext = 199
3231    }
3232    export enum JsxEmit {
3233        None = 0,
3234        Preserve = 1,
3235        React = 2,
3236        ReactNative = 3,
3237        ReactJSX = 4,
3238        ReactJSXDev = 5
3239    }
3240    export enum ImportsNotUsedAsValues {
3241        Remove = 0,
3242        Preserve = 1,
3243        Error = 2
3244    }
3245    export enum NewLineKind {
3246        CarriageReturnLineFeed = 0,
3247        LineFeed = 1
3248    }
3249    export interface LineAndCharacter {
3250        /** 0-based. */
3251        line: number;
3252        character: number;
3253    }
3254    export enum ScriptKind {
3255        Unknown = 0,
3256        JS = 1,
3257        JSX = 2,
3258        TS = 3,
3259        TSX = 4,
3260        External = 5,
3261        JSON = 6,
3262        /**
3263         * Used on extensions that doesn't define the ScriptKind but the content defines it.
3264         * Deferred extensions are going to be included in all project contexts.
3265         */
3266        Deferred = 7,
3267        ETS = 8
3268    }
3269    export enum ScriptTarget {
3270        ES3 = 0,
3271        ES5 = 1,
3272        ES2015 = 2,
3273        ES2016 = 3,
3274        ES2017 = 4,
3275        ES2018 = 5,
3276        ES2019 = 6,
3277        ES2020 = 7,
3278        ES2021 = 8,
3279        ES2022 = 9,
3280        ESNext = 99,
3281        JSON = 100,
3282        Latest = 99
3283    }
3284    export enum LanguageVariant {
3285        Standard = 0,
3286        JSX = 1
3287    }
3288    /** Either a parsed command line or a parsed tsconfig.json */
3289    export interface ParsedCommandLine {
3290        options: CompilerOptions;
3291        typeAcquisition?: TypeAcquisition;
3292        fileNames: string[];
3293        projectReferences?: readonly ProjectReference[];
3294        watchOptions?: WatchOptions;
3295        raw?: any;
3296        errors: Diagnostic[];
3297        wildcardDirectories?: MapLike<WatchDirectoryFlags>;
3298        compileOnSave?: boolean;
3299    }
3300    export enum WatchDirectoryFlags {
3301        None = 0,
3302        Recursive = 1
3303    }
3304    export interface CreateProgramOptions {
3305        rootNames: readonly string[];
3306        options: CompilerOptions;
3307        projectReferences?: readonly ProjectReference[];
3308        host?: CompilerHost;
3309        oldProgram?: Program;
3310        configFileParsingDiagnostics?: readonly Diagnostic[];
3311    }
3312    export interface ModuleResolutionHost {
3313        fileExists(fileName: string): boolean;
3314        readFile(fileName: string): string | undefined;
3315        trace?(s: string): void;
3316        directoryExists?(directoryName: string): boolean;
3317        /**
3318         * Resolve a symbolic link.
3319         * @see https://nodejs.org/api/fs.html#fs_fs_realpathsync_path_options
3320         */
3321        realpath?(path: string): string;
3322        getCurrentDirectory?(): string;
3323        getDirectories?(path: string): string[];
3324        useCaseSensitiveFileNames?: boolean | (() => boolean) | undefined;
3325        getJsDocNodeCheckedConfig?(jsDocFileCheckInfo: FileCheckModuleInfo, symbolSourceFilePath: string): JsDocNodeCheckConfig;
3326        getJsDocNodeConditionCheckedResult?(jsDocFileCheckedInfo: FileCheckModuleInfo, jsDocs: JsDocTagInfo[]): ConditionCheckResult;
3327        getFileCheckedModuleInfo?(containFilePath: string): FileCheckModuleInfo;
3328    }
3329    /**
3330     * Used by services to specify the minimum host area required to set up source files under any compilation settings
3331     */
3332    export interface MinimalResolutionCacheHost extends ModuleResolutionHost {
3333        getCompilationSettings(): CompilerOptions;
3334        getCompilerHost?(): CompilerHost | undefined;
3335    }
3336    /**
3337     * Represents the result of module resolution.
3338     * Module resolution will pick up tsx/jsx/js files even if '--jsx' and '--allowJs' are turned off.
3339     * The Program will then filter results based on these flags.
3340     *
3341     * Prefer to return a `ResolvedModuleFull` so that the file type does not have to be inferred.
3342     */
3343    export interface ResolvedModule {
3344        /** Path of the file the module was resolved to. */
3345        resolvedFileName: string;
3346        /** True if `resolvedFileName` comes from `node_modules`. */
3347        isExternalLibraryImport?: boolean;
3348    }
3349    /**
3350     * ResolvedModule with an explicitly provided `extension` property.
3351     * Prefer this over `ResolvedModule`.
3352     * If changing this, remember to change `moduleResolutionIsEqualTo`.
3353     */
3354    export interface ResolvedModuleFull extends ResolvedModule {
3355        /**
3356         * Extension of resolvedFileName. This must match what's at the end of resolvedFileName.
3357         * This is optional for backwards-compatibility, but will be added if not provided.
3358         */
3359        extension: Extension;
3360        packageId?: PackageId;
3361    }
3362    /**
3363     * Unique identifier with a package name and version.
3364     * If changing this, remember to change `packageIdIsEqual`.
3365     */
3366    export interface PackageId {
3367        /**
3368         * Name of the package.
3369         * Should not include `@types`.
3370         * If accessing a non-index file, this should include its name e.g. "foo/bar".
3371         */
3372        name: string;
3373        /**
3374         * Name of a submodule within this package.
3375         * May be "".
3376         */
3377        subModuleName: string;
3378        /** Version of the package, e.g. "1.2.3" */
3379        version: string;
3380    }
3381    export enum Extension {
3382        Ts = ".ts",
3383        Tsx = ".tsx",
3384        Dts = ".d.ts",
3385        Js = ".js",
3386        Jsx = ".jsx",
3387        Json = ".json",
3388        TsBuildInfo = ".tsbuildinfo",
3389        Mjs = ".mjs",
3390        Mts = ".mts",
3391        Dmts = ".d.mts",
3392        Cjs = ".cjs",
3393        Cts = ".cts",
3394        Dcts = ".d.cts",
3395        Ets = ".ets",
3396        Dets = ".d.ets"
3397    }
3398    export interface ResolvedModuleWithFailedLookupLocations {
3399        readonly resolvedModule: ResolvedModuleFull | undefined;
3400    }
3401    export interface ResolvedTypeReferenceDirective {
3402        primary: boolean;
3403        resolvedFileName: string | undefined;
3404        packageId?: PackageId;
3405        /** True if `resolvedFileName` comes from `node_modules` or `oh_modules`. */
3406        isExternalLibraryImport?: boolean;
3407    }
3408    export interface ResolvedTypeReferenceDirectiveWithFailedLookupLocations {
3409        readonly resolvedTypeReferenceDirective: ResolvedTypeReferenceDirective | undefined;
3410        readonly failedLookupLocations: string[];
3411    }
3412    export interface FileCheckModuleInfo {
3413        fileNeedCheck: boolean;
3414        checkPayload: any;
3415        currentFileName: string;
3416    }
3417    export interface JsDocNodeCheckConfig {
3418        nodeNeedCheck: boolean;
3419        checkConfig: JsDocNodeCheckConfigItem[];
3420    }
3421    export interface JsDocNodeCheckConfigItem {
3422        tagName: string[];
3423        message: string;
3424        needConditionCheck: boolean;
3425        type: DiagnosticCategory;
3426        specifyCheckConditionFuncName: string;
3427        tagNameShouldExisted: boolean;
3428        checkValidCallback?: (jsDocTag: JSDocTag, config: JsDocNodeCheckConfigItem) => boolean;
3429        checkJsDocSpecialValidCallback?: (jsDocTags: readonly JSDocTag[], config: JsDocNodeCheckConfigItem) => boolean;
3430    }
3431    export interface TagCheckParam {
3432        needCheck: boolean;
3433        checkConfig: TagCheckConfig[];
3434    }
3435    export interface TagCheckConfig {
3436        tagName: string;
3437        message: string;
3438        needConditionCheck: boolean;
3439        specifyCheckConditionFuncName: string;
3440    }
3441    export interface ConditionCheckResult {
3442        valid: boolean;
3443        type?: DiagnosticCategory;
3444        message?: string;
3445    }
3446    export interface CompilerHost extends ModuleResolutionHost {
3447        getSourceFile(fileName: string, languageVersionOrOptions: ScriptTarget | CreateSourceFileOptions, onError?: (message: string) => void, shouldCreateNewSourceFile?: boolean): SourceFile | undefined;
3448        getSourceFileByPath?(fileName: string, path: Path, languageVersionOrOptions: ScriptTarget | CreateSourceFileOptions, onError?: (message: string) => void, shouldCreateNewSourceFile?: boolean): SourceFile | undefined;
3449        getCancellationToken?(): CancellationToken;
3450        getDefaultLibFileName(options: CompilerOptions): string;
3451        getDefaultLibLocation?(): string;
3452        writeFile: WriteFileCallback;
3453        getCurrentDirectory(): string;
3454        getCanonicalFileName(fileName: string): string;
3455        useCaseSensitiveFileNames(): boolean;
3456        getNewLine(): string;
3457        readDirectory?(rootDir: string, extensions: readonly string[], excludes: readonly string[] | undefined, includes: readonly string[], depth?: number): string[];
3458        resolveModuleNames?(moduleNames: string[], containingFile: string, reusedNames: string[] | undefined, redirectedReference: ResolvedProjectReference | undefined, options: CompilerOptions, containingSourceFile?: SourceFile): (ResolvedModule | undefined)[];
3459        /**
3460         * 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
3461         */
3462        getModuleResolutionCache?(): ModuleResolutionCache | undefined;
3463        /**
3464         * This method is a companion for 'resolveModuleNames' and is used to resolve 'types' references to actual type declaration files
3465         */
3466        resolveTypeReferenceDirectives?(typeReferenceDirectiveNames: string[] | readonly FileReference[], containingFile: string, redirectedReference: ResolvedProjectReference | undefined, options: CompilerOptions, containingFileMode?: SourceFile["impliedNodeFormat"] | undefined): (ResolvedTypeReferenceDirective | undefined)[];
3467        getEnvironmentVariable?(name: string): string | undefined;
3468        /** If provided along with custom resolveModuleNames or resolveTypeReferenceDirectives, used to determine if unchanged file path needs to re-resolve modules/type reference directives */
3469        hasInvalidatedResolutions?(filePath: Path): boolean;
3470        createHash?(data: string): string;
3471        getParsedCommandLine?(fileName: string): ParsedCommandLine | undefined;
3472        /**
3473         * get tagName where need to be determined based on the file path
3474         * @param jsDocFileCheckInfo filePath
3475         * @param symbolSourceFilePath filePath
3476         */
3477        getJsDocNodeCheckedConfig?(jsDocFileCheckInfo: FileCheckModuleInfo, symbolSourceFilePath: string): JsDocNodeCheckConfig;
3478        /**
3479         * get checked results based on the file path and jsDocs
3480         * @param jsDocFileCheckedInfo
3481         * @param jsDocs
3482         */
3483        getJsDocNodeConditionCheckedResult?(jsDocFileCheckedInfo: FileCheckModuleInfo, jsDocs: JsDocTagInfo[]): ConditionCheckResult;
3484        getFileCheckedModuleInfo?(containFilePath: string): FileCheckModuleInfo;
3485        getLastCompiledProgram?(): Program;
3486    }
3487    export interface SourceMapRange extends TextRange {
3488        source?: SourceMapSource;
3489    }
3490    export interface SourceMapSource {
3491        fileName: string;
3492        text: string;
3493        skipTrivia?: (pos: number) => number;
3494    }
3495    export enum EmitFlags {
3496        None = 0,
3497        SingleLine = 1,
3498        AdviseOnEmitNode = 2,
3499        NoSubstitution = 4,
3500        CapturesThis = 8,
3501        NoLeadingSourceMap = 16,
3502        NoTrailingSourceMap = 32,
3503        NoSourceMap = 48,
3504        NoNestedSourceMaps = 64,
3505        NoTokenLeadingSourceMaps = 128,
3506        NoTokenTrailingSourceMaps = 256,
3507        NoTokenSourceMaps = 384,
3508        NoLeadingComments = 512,
3509        NoTrailingComments = 1024,
3510        NoComments = 1536,
3511        NoNestedComments = 2048,
3512        HelperName = 4096,
3513        ExportName = 8192,
3514        LocalName = 16384,
3515        InternalName = 32768,
3516        Indented = 65536,
3517        NoIndentation = 131072,
3518        AsyncFunctionBody = 262144,
3519        ReuseTempVariableScope = 524288,
3520        CustomPrologue = 1048576,
3521        NoHoisting = 2097152,
3522        HasEndOfDeclarationMarker = 4194304,
3523        Iterator = 8388608,
3524        NoAsciiEscaping = 16777216,
3525    }
3526    export interface EmitHelperBase {
3527        readonly name: string;
3528        readonly scoped: boolean;
3529        readonly text: string | ((node: EmitHelperUniqueNameCallback) => string);
3530        readonly priority?: number;
3531        readonly dependencies?: EmitHelper[];
3532    }
3533    export interface ScopedEmitHelper extends EmitHelperBase {
3534        readonly scoped: true;
3535    }
3536    export interface UnscopedEmitHelper extends EmitHelperBase {
3537        readonly scoped: false;
3538        readonly text: string;
3539    }
3540    export type EmitHelper = ScopedEmitHelper | UnscopedEmitHelper;
3541    export type EmitHelperUniqueNameCallback = (name: string) => string;
3542    export enum EmitHint {
3543        SourceFile = 0,
3544        Expression = 1,
3545        IdentifierName = 2,
3546        MappedTypeParameter = 3,
3547        Unspecified = 4,
3548        EmbeddedStatement = 5,
3549        JsxAttributeValue = 6
3550    }
3551    export interface SourceFileMayBeEmittedHost {
3552        getCompilerOptions(): CompilerOptions;
3553        isSourceFileFromExternalLibrary(file: SourceFile): boolean;
3554        getResolvedProjectReferenceToRedirect(fileName: string): ResolvedProjectReference | undefined;
3555        isSourceOfProjectReferenceRedirect(fileName: string): boolean;
3556    }
3557    export interface EmitHost extends ScriptReferenceHost, ModuleSpecifierResolutionHost, SourceFileMayBeEmittedHost {
3558        getSourceFiles(): readonly SourceFile[];
3559        useCaseSensitiveFileNames(): boolean;
3560        getCurrentDirectory(): string;
3561        getLibFileFromReference(ref: FileReference): SourceFile | undefined;
3562        getCommonSourceDirectory(): string;
3563        getCanonicalFileName(fileName: string): string;
3564        getNewLine(): string;
3565        isEmitBlocked(emitFileName: string): boolean;
3566        getPrependNodes(): readonly (InputFiles | UnparsedSource)[];
3567        writeFile: WriteFileCallback;
3568        getSourceFileFromReference: Program["getSourceFileFromReference"];
3569        readonly redirectTargetsMap: RedirectTargetsMap;
3570        createHash?(data: string): string;
3571    }
3572    export enum OuterExpressionKinds {
3573        Parentheses = 1,
3574        TypeAssertions = 2,
3575        NonNullAssertions = 4,
3576        PartiallyEmittedExpressions = 8,
3577        Assertions = 6,
3578        All = 15,
3579        ExcludeJSDocTypeAssertion = 16
3580    }
3581    export type TypeOfTag = "undefined" | "number" | "bigint" | "boolean" | "string" | "symbol" | "object" | "function";
3582    export interface NodeFactory {
3583        createNodeArray<T extends Node>(elements?: readonly T[], hasTrailingComma?: boolean): NodeArray<T>;
3584        createNumericLiteral(value: string | number, numericLiteralFlags?: TokenFlags): NumericLiteral;
3585        createBigIntLiteral(value: string | PseudoBigInt): BigIntLiteral;
3586        createStringLiteral(text: string, isSingleQuote?: boolean): StringLiteral;
3587        createStringLiteralFromNode(sourceNode: PropertyNameLiteral | PrivateIdentifier, isSingleQuote?: boolean): StringLiteral;
3588        createRegularExpressionLiteral(text: string): RegularExpressionLiteral;
3589        createIdentifier(text: string): Identifier;
3590        /**
3591         * Create a unique temporary variable.
3592         * @param recordTempVariable An optional callback used to record the temporary variable name. This
3593         * should usually be a reference to `hoistVariableDeclaration` from a `TransformationContext`, but
3594         * can be `undefined` if you plan to record the temporary variable manually.
3595         * @param reservedInNestedScopes When `true`, reserves the temporary variable name in all nested scopes
3596         * during emit so that the variable can be referenced in a nested function body. This is an alternative to
3597         * setting `EmitFlags.ReuseTempVariableScope` on the nested function itself.
3598         */
3599        createTempVariable(recordTempVariable: ((node: Identifier) => void) | undefined, reservedInNestedScopes?: boolean): Identifier;
3600        /**
3601         * Create a unique temporary variable for use in a loop.
3602         * @param reservedInNestedScopes When `true`, reserves the temporary variable name in all nested scopes
3603         * during emit so that the variable can be referenced in a nested function body. This is an alternative to
3604         * setting `EmitFlags.ReuseTempVariableScope` on the nested function itself.
3605         */
3606        createLoopVariable(reservedInNestedScopes?: boolean): Identifier;
3607        /** Create a unique name based on the supplied text. */
3608        createUniqueName(text: string, flags?: GeneratedIdentifierFlags): Identifier;
3609        /** Create a unique name generated for a node. */
3610        getGeneratedNameForNode(node: Node | undefined, flags?: GeneratedIdentifierFlags): Identifier;
3611        createPrivateIdentifier(text: string): PrivateIdentifier;
3612        createUniquePrivateName(text?: string): PrivateIdentifier;
3613        getGeneratedPrivateNameForNode(node: Node): PrivateIdentifier;
3614        createToken(token: SyntaxKind.SuperKeyword): SuperExpression;
3615        createToken(token: SyntaxKind.ThisKeyword): ThisExpression;
3616        createToken(token: SyntaxKind.NullKeyword): NullLiteral;
3617        createToken(token: SyntaxKind.TrueKeyword): TrueLiteral;
3618        createToken(token: SyntaxKind.FalseKeyword): FalseLiteral;
3619        createToken<TKind extends PunctuationSyntaxKind>(token: TKind): PunctuationToken<TKind>;
3620        createToken<TKind extends KeywordTypeSyntaxKind>(token: TKind): KeywordTypeNode<TKind>;
3621        createToken<TKind extends ModifierSyntaxKind>(token: TKind): ModifierToken<TKind>;
3622        createToken<TKind extends KeywordSyntaxKind>(token: TKind): KeywordToken<TKind>;
3623        createToken<TKind extends SyntaxKind.Unknown | SyntaxKind.EndOfFileToken>(token: TKind): Token<TKind>;
3624        createSuper(): SuperExpression;
3625        createThis(): ThisExpression;
3626        createNull(): NullLiteral;
3627        createTrue(): TrueLiteral;
3628        createFalse(): FalseLiteral;
3629        createModifier<T extends ModifierSyntaxKind>(kind: T): ModifierToken<T>;
3630        createModifiersFromModifierFlags(flags: ModifierFlags): Modifier[] | undefined;
3631        createQualifiedName(left: EntityName, right: string | Identifier): QualifiedName;
3632        updateQualifiedName(node: QualifiedName, left: EntityName, right: Identifier): QualifiedName;
3633        createComputedPropertyName(expression: Expression): ComputedPropertyName;
3634        updateComputedPropertyName(node: ComputedPropertyName, expression: Expression): ComputedPropertyName;
3635        createTypeParameterDeclaration(modifiers: readonly Modifier[] | undefined, name: string | Identifier, constraint?: TypeNode, defaultType?: TypeNode): TypeParameterDeclaration;
3636        updateTypeParameterDeclaration(node: TypeParameterDeclaration, modifiers: readonly Modifier[] | undefined, name: Identifier, constraint: TypeNode | undefined, defaultType: TypeNode | undefined): TypeParameterDeclaration;
3637        createParameterDeclaration(modifiers: readonly ModifierLike[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken?: QuestionToken, type?: TypeNode, initializer?: Expression): ParameterDeclaration;
3638        updateParameterDeclaration(node: ParameterDeclaration, modifiers: readonly ModifierLike[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): ParameterDeclaration;
3639        createDecorator(expression: Expression): Decorator;
3640        updateDecorator(node: Decorator, expression: Expression): Decorator;
3641        createPropertySignature(modifiers: readonly Modifier[] | undefined, name: PropertyName | string, questionToken: QuestionToken | undefined, type: TypeNode | undefined): PropertySignature;
3642        updatePropertySignature(node: PropertySignature, modifiers: readonly Modifier[] | undefined, name: PropertyName, questionToken: QuestionToken | undefined, type: TypeNode | undefined): PropertySignature;
3643        createPropertyDeclaration(modifiers: readonly ModifierLike[] | undefined, name: string | PropertyName, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertyDeclaration;
3644        updatePropertyDeclaration(node: PropertyDeclaration, modifiers: readonly ModifierLike[] | undefined, name: string | PropertyName, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertyDeclaration;
3645        createMethodSignature(modifiers: readonly Modifier[] | undefined, name: string | PropertyName, questionToken: QuestionToken | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined): MethodSignature;
3646        updateMethodSignature(node: MethodSignature, modifiers: readonly Modifier[] | undefined, name: PropertyName, questionToken: QuestionToken | undefined, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined): MethodSignature;
3647        createMethodDeclaration(modifiers: readonly ModifierLike[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | PropertyName, questionToken: QuestionToken | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): MethodDeclaration;
3648        updateMethodDeclaration(node: MethodDeclaration, modifiers: readonly ModifierLike[] | undefined, asteriskToken: AsteriskToken | undefined, name: PropertyName, questionToken: QuestionToken | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): MethodDeclaration;
3649        createConstructorDeclaration(modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], body: Block | undefined): ConstructorDeclaration;
3650        updateConstructorDeclaration(node: ConstructorDeclaration, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], body: Block | undefined): ConstructorDeclaration;
3651        createGetAccessorDeclaration(modifiers: readonly ModifierLike[] | undefined, name: string | PropertyName, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): GetAccessorDeclaration;
3652        updateGetAccessorDeclaration(node: GetAccessorDeclaration, modifiers: readonly ModifierLike[] | undefined, name: PropertyName, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): GetAccessorDeclaration;
3653        createSetAccessorDeclaration(modifiers: readonly ModifierLike[] | undefined, name: string | PropertyName, parameters: readonly ParameterDeclaration[], body: Block | undefined): SetAccessorDeclaration;
3654        updateSetAccessorDeclaration(node: SetAccessorDeclaration, modifiers: readonly ModifierLike[] | undefined, name: PropertyName, parameters: readonly ParameterDeclaration[], body: Block | undefined): SetAccessorDeclaration;
3655        createCallSignature(typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined): CallSignatureDeclaration;
3656        updateCallSignature(node: CallSignatureDeclaration, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined): CallSignatureDeclaration;
3657        createConstructSignature(typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined): ConstructSignatureDeclaration;
3658        updateConstructSignature(node: ConstructSignatureDeclaration, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined): ConstructSignatureDeclaration;
3659        createIndexSignature(modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration;
3660        updateIndexSignature(node: IndexSignatureDeclaration, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration;
3661        createTemplateLiteralTypeSpan(type: TypeNode, literal: TemplateMiddle | TemplateTail): TemplateLiteralTypeSpan;
3662        updateTemplateLiteralTypeSpan(node: TemplateLiteralTypeSpan, type: TypeNode, literal: TemplateMiddle | TemplateTail): TemplateLiteralTypeSpan;
3663        createClassStaticBlockDeclaration(body: Block): ClassStaticBlockDeclaration;
3664        updateClassStaticBlockDeclaration(node: ClassStaticBlockDeclaration, body: Block): ClassStaticBlockDeclaration;
3665        createKeywordTypeNode<TKind extends KeywordTypeSyntaxKind>(kind: TKind): KeywordTypeNode<TKind>;
3666        createTypePredicateNode(assertsModifier: AssertsKeyword | undefined, parameterName: Identifier | ThisTypeNode | string, type: TypeNode | undefined): TypePredicateNode;
3667        updateTypePredicateNode(node: TypePredicateNode, assertsModifier: AssertsKeyword | undefined, parameterName: Identifier | ThisTypeNode, type: TypeNode | undefined): TypePredicateNode;
3668        createTypeReferenceNode(typeName: string | EntityName, typeArguments?: readonly TypeNode[]): TypeReferenceNode;
3669        updateTypeReferenceNode(node: TypeReferenceNode, typeName: EntityName, typeArguments: NodeArray<TypeNode> | undefined): TypeReferenceNode;
3670        createFunctionTypeNode(typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): FunctionTypeNode;
3671        updateFunctionTypeNode(node: FunctionTypeNode, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode): FunctionTypeNode;
3672        createConstructorTypeNode(modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): ConstructorTypeNode;
3673        updateConstructorTypeNode(node: ConstructorTypeNode, modifiers: readonly Modifier[] | undefined, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode): ConstructorTypeNode;
3674        createTypeQueryNode(exprName: EntityName, typeArguments?: readonly TypeNode[]): TypeQueryNode;
3675        updateTypeQueryNode(node: TypeQueryNode, exprName: EntityName, typeArguments?: readonly TypeNode[]): TypeQueryNode;
3676        createTypeLiteralNode(members: readonly TypeElement[] | undefined): TypeLiteralNode;
3677        updateTypeLiteralNode(node: TypeLiteralNode, members: NodeArray<TypeElement>): TypeLiteralNode;
3678        createArrayTypeNode(elementType: TypeNode): ArrayTypeNode;
3679        updateArrayTypeNode(node: ArrayTypeNode, elementType: TypeNode): ArrayTypeNode;
3680        createTupleTypeNode(elements: readonly (TypeNode | NamedTupleMember)[]): TupleTypeNode;
3681        updateTupleTypeNode(node: TupleTypeNode, elements: readonly (TypeNode | NamedTupleMember)[]): TupleTypeNode;
3682        createNamedTupleMember(dotDotDotToken: DotDotDotToken | undefined, name: Identifier, questionToken: QuestionToken | undefined, type: TypeNode): NamedTupleMember;
3683        updateNamedTupleMember(node: NamedTupleMember, dotDotDotToken: DotDotDotToken | undefined, name: Identifier, questionToken: QuestionToken | undefined, type: TypeNode): NamedTupleMember;
3684        createOptionalTypeNode(type: TypeNode): OptionalTypeNode;
3685        updateOptionalTypeNode(node: OptionalTypeNode, type: TypeNode): OptionalTypeNode;
3686        createRestTypeNode(type: TypeNode): RestTypeNode;
3687        updateRestTypeNode(node: RestTypeNode, type: TypeNode): RestTypeNode;
3688        createUnionTypeNode(types: readonly TypeNode[]): UnionTypeNode;
3689        updateUnionTypeNode(node: UnionTypeNode, types: NodeArray<TypeNode>): UnionTypeNode;
3690        createIntersectionTypeNode(types: readonly TypeNode[]): IntersectionTypeNode;
3691        updateIntersectionTypeNode(node: IntersectionTypeNode, types: NodeArray<TypeNode>): IntersectionTypeNode;
3692        createConditionalTypeNode(checkType: TypeNode, extendsType: TypeNode, trueType: TypeNode, falseType: TypeNode): ConditionalTypeNode;
3693        updateConditionalTypeNode(node: ConditionalTypeNode, checkType: TypeNode, extendsType: TypeNode, trueType: TypeNode, falseType: TypeNode): ConditionalTypeNode;
3694        createInferTypeNode(typeParameter: TypeParameterDeclaration): InferTypeNode;
3695        updateInferTypeNode(node: InferTypeNode, typeParameter: TypeParameterDeclaration): InferTypeNode;
3696        createImportTypeNode(argument: TypeNode, assertions?: ImportTypeAssertionContainer, qualifier?: EntityName, typeArguments?: readonly TypeNode[], isTypeOf?: boolean): ImportTypeNode;
3697        updateImportTypeNode(node: ImportTypeNode, argument: TypeNode, assertions: ImportTypeAssertionContainer | undefined, qualifier: EntityName | undefined, typeArguments: readonly TypeNode[] | undefined, isTypeOf?: boolean): ImportTypeNode;
3698        createParenthesizedType(type: TypeNode): ParenthesizedTypeNode;
3699        updateParenthesizedType(node: ParenthesizedTypeNode, type: TypeNode): ParenthesizedTypeNode;
3700        createThisTypeNode(): ThisTypeNode;
3701        createTypeOperatorNode(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword, type: TypeNode): TypeOperatorNode;
3702        updateTypeOperatorNode(node: TypeOperatorNode, type: TypeNode): TypeOperatorNode;
3703        createIndexedAccessTypeNode(objectType: TypeNode, indexType: TypeNode): IndexedAccessTypeNode;
3704        updateIndexedAccessTypeNode(node: IndexedAccessTypeNode, objectType: TypeNode, indexType: TypeNode): IndexedAccessTypeNode;
3705        createMappedTypeNode(readonlyToken: ReadonlyKeyword | PlusToken | MinusToken | undefined, typeParameter: TypeParameterDeclaration, nameType: TypeNode | undefined, questionToken: QuestionToken | PlusToken | MinusToken | undefined, type: TypeNode | undefined, members: NodeArray<TypeElement> | undefined): MappedTypeNode;
3706        updateMappedTypeNode(node: MappedTypeNode, readonlyToken: ReadonlyKeyword | PlusToken | MinusToken | undefined, typeParameter: TypeParameterDeclaration, nameType: TypeNode | undefined, questionToken: QuestionToken | PlusToken | MinusToken | undefined, type: TypeNode | undefined, members: NodeArray<TypeElement> | undefined): MappedTypeNode;
3707        createLiteralTypeNode(literal: LiteralTypeNode["literal"]): LiteralTypeNode;
3708        updateLiteralTypeNode(node: LiteralTypeNode, literal: LiteralTypeNode["literal"]): LiteralTypeNode;
3709        createTemplateLiteralType(head: TemplateHead, templateSpans: readonly TemplateLiteralTypeSpan[]): TemplateLiteralTypeNode;
3710        updateTemplateLiteralType(node: TemplateLiteralTypeNode, head: TemplateHead, templateSpans: readonly TemplateLiteralTypeSpan[]): TemplateLiteralTypeNode;
3711        createObjectBindingPattern(elements: readonly BindingElement[]): ObjectBindingPattern;
3712        updateObjectBindingPattern(node: ObjectBindingPattern, elements: readonly BindingElement[]): ObjectBindingPattern;
3713        createArrayBindingPattern(elements: readonly ArrayBindingElement[]): ArrayBindingPattern;
3714        updateArrayBindingPattern(node: ArrayBindingPattern, elements: readonly ArrayBindingElement[]): ArrayBindingPattern;
3715        createBindingElement(dotDotDotToken: DotDotDotToken | undefined, propertyName: string | PropertyName | undefined, name: string | BindingName, initializer?: Expression): BindingElement;
3716        updateBindingElement(node: BindingElement, dotDotDotToken: DotDotDotToken | undefined, propertyName: PropertyName | undefined, name: BindingName, initializer: Expression | undefined): BindingElement;
3717        createArrayLiteralExpression(elements?: readonly Expression[], multiLine?: boolean): ArrayLiteralExpression;
3718        updateArrayLiteralExpression(node: ArrayLiteralExpression, elements: readonly Expression[]): ArrayLiteralExpression;
3719        createObjectLiteralExpression(properties?: readonly ObjectLiteralElementLike[], multiLine?: boolean): ObjectLiteralExpression;
3720        updateObjectLiteralExpression(node: ObjectLiteralExpression, properties: readonly ObjectLiteralElementLike[]): ObjectLiteralExpression;
3721        createPropertyAccessExpression(expression: Expression, name: string | MemberName): PropertyAccessExpression;
3722        updatePropertyAccessExpression(node: PropertyAccessExpression, expression: Expression, name: MemberName): PropertyAccessExpression;
3723        createPropertyAccessChain(expression: Expression, questionDotToken: QuestionDotToken | undefined, name: string | MemberName): PropertyAccessChain;
3724        updatePropertyAccessChain(node: PropertyAccessChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, name: MemberName): PropertyAccessChain;
3725        createElementAccessExpression(expression: Expression, index: number | Expression): ElementAccessExpression;
3726        updateElementAccessExpression(node: ElementAccessExpression, expression: Expression, argumentExpression: Expression): ElementAccessExpression;
3727        createElementAccessChain(expression: Expression, questionDotToken: QuestionDotToken | undefined, index: number | Expression): ElementAccessChain;
3728        updateElementAccessChain(node: ElementAccessChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, argumentExpression: Expression): ElementAccessChain;
3729        createCallExpression(expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): CallExpression;
3730        updateCallExpression(node: CallExpression, expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[]): CallExpression;
3731        createCallChain(expression: Expression, questionDotToken: QuestionDotToken | undefined, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): CallChain;
3732        updateCallChain(node: CallChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[]): CallChain;
3733        createNewExpression(expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): NewExpression;
3734        updateNewExpression(node: NewExpression, expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): NewExpression;
3735        createTaggedTemplateExpression(tag: Expression, typeArguments: readonly TypeNode[] | undefined, template: TemplateLiteral): TaggedTemplateExpression;
3736        updateTaggedTemplateExpression(node: TaggedTemplateExpression, tag: Expression, typeArguments: readonly TypeNode[] | undefined, template: TemplateLiteral): TaggedTemplateExpression;
3737        createTypeAssertion(type: TypeNode, expression: Expression): TypeAssertion;
3738        updateTypeAssertion(node: TypeAssertion, type: TypeNode, expression: Expression): TypeAssertion;
3739        createParenthesizedExpression(expression: Expression): ParenthesizedExpression;
3740        updateParenthesizedExpression(node: ParenthesizedExpression, expression: Expression): ParenthesizedExpression;
3741        createFunctionExpression(modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[] | undefined, type: TypeNode | undefined, body: Block): FunctionExpression;
3742        updateFunctionExpression(node: FunctionExpression, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block): FunctionExpression;
3743        createArrowFunction(modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, equalsGreaterThanToken: EqualsGreaterThanToken | undefined, body: ConciseBody): ArrowFunction;
3744        updateArrowFunction(node: ArrowFunction, modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, equalsGreaterThanToken: EqualsGreaterThanToken, body: ConciseBody): ArrowFunction;
3745        createEtsComponentExpression(name: Expression, argumentExpression: Expression[] | NodeArray<Expression> | undefined, body: Block | undefined): EtsComponentExpression;
3746        updateEtsComponentExpression(node: EtsComponentExpression, name: Expression | undefined, argumentExpression: Expression[] | NodeArray<Expression> | undefined, body: Block | undefined): EtsComponentExpression;
3747        createDeleteExpression(expression: Expression): DeleteExpression;
3748        updateDeleteExpression(node: DeleteExpression, expression: Expression): DeleteExpression;
3749        createTypeOfExpression(expression: Expression): TypeOfExpression;
3750        updateTypeOfExpression(node: TypeOfExpression, expression: Expression): TypeOfExpression;
3751        createVoidExpression(expression: Expression): VoidExpression;
3752        updateVoidExpression(node: VoidExpression, expression: Expression): VoidExpression;
3753        createAwaitExpression(expression: Expression): AwaitExpression;
3754        updateAwaitExpression(node: AwaitExpression, expression: Expression): AwaitExpression;
3755        createPrefixUnaryExpression(operator: PrefixUnaryOperator, operand: Expression): PrefixUnaryExpression;
3756        updatePrefixUnaryExpression(node: PrefixUnaryExpression, operand: Expression): PrefixUnaryExpression;
3757        createPostfixUnaryExpression(operand: Expression, operator: PostfixUnaryOperator): PostfixUnaryExpression;
3758        updatePostfixUnaryExpression(node: PostfixUnaryExpression, operand: Expression): PostfixUnaryExpression;
3759        createBinaryExpression(left: Expression, operator: BinaryOperator | BinaryOperatorToken, right: Expression): BinaryExpression;
3760        updateBinaryExpression(node: BinaryExpression, left: Expression, operator: BinaryOperator | BinaryOperatorToken, right: Expression): BinaryExpression;
3761        createConditionalExpression(condition: Expression, questionToken: QuestionToken | undefined, whenTrue: Expression, colonToken: ColonToken | undefined, whenFalse: Expression): ConditionalExpression;
3762        updateConditionalExpression(node: ConditionalExpression, condition: Expression, questionToken: QuestionToken, whenTrue: Expression, colonToken: ColonToken, whenFalse: Expression): ConditionalExpression;
3763        createTemplateExpression(head: TemplateHead, templateSpans: readonly TemplateSpan[]): TemplateExpression;
3764        updateTemplateExpression(node: TemplateExpression, head: TemplateHead, templateSpans: readonly TemplateSpan[]): TemplateExpression;
3765        createTemplateHead(text: string, rawText?: string, templateFlags?: TokenFlags): TemplateHead;
3766        createTemplateHead(text: string | undefined, rawText: string, templateFlags?: TokenFlags): TemplateHead;
3767        createTemplateMiddle(text: string, rawText?: string, templateFlags?: TokenFlags): TemplateMiddle;
3768        createTemplateMiddle(text: string | undefined, rawText: string, templateFlags?: TokenFlags): TemplateMiddle;
3769        createTemplateTail(text: string, rawText?: string, templateFlags?: TokenFlags): TemplateTail;
3770        createTemplateTail(text: string | undefined, rawText: string, templateFlags?: TokenFlags): TemplateTail;
3771        createNoSubstitutionTemplateLiteral(text: string, rawText?: string): NoSubstitutionTemplateLiteral;
3772        createNoSubstitutionTemplateLiteral(text: string | undefined, rawText: string): NoSubstitutionTemplateLiteral;
3773        createYieldExpression(asteriskToken: AsteriskToken, expression: Expression): YieldExpression;
3774        createYieldExpression(asteriskToken: undefined, expression: Expression | undefined): YieldExpression;
3775        updateYieldExpression(node: YieldExpression, asteriskToken: AsteriskToken | undefined, expression: Expression | undefined): YieldExpression;
3776        createSpreadElement(expression: Expression): SpreadElement;
3777        updateSpreadElement(node: SpreadElement, expression: Expression): SpreadElement;
3778        createClassExpression(modifiers: readonly ModifierLike[] | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassExpression;
3779        updateClassExpression(node: ClassExpression, modifiers: readonly ModifierLike[] | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassExpression;
3780        createOmittedExpression(): OmittedExpression;
3781        createExpressionWithTypeArguments(expression: Expression, typeArguments: readonly TypeNode[] | undefined): ExpressionWithTypeArguments;
3782        updateExpressionWithTypeArguments(node: ExpressionWithTypeArguments, expression: Expression, typeArguments: readonly TypeNode[] | undefined): ExpressionWithTypeArguments;
3783        createAsExpression(expression: Expression, type: TypeNode): AsExpression;
3784        updateAsExpression(node: AsExpression, expression: Expression, type: TypeNode): AsExpression;
3785        createNonNullExpression(expression: Expression): NonNullExpression;
3786        updateNonNullExpression(node: NonNullExpression, expression: Expression): NonNullExpression;
3787        createNonNullChain(expression: Expression): NonNullChain;
3788        updateNonNullChain(node: NonNullChain, expression: Expression): NonNullChain;
3789        createMetaProperty(keywordToken: MetaProperty["keywordToken"], name: Identifier): MetaProperty;
3790        updateMetaProperty(node: MetaProperty, name: Identifier): MetaProperty;
3791        createSatisfiesExpression(expression: Expression, type: TypeNode): SatisfiesExpression;
3792        updateSatisfiesExpression(node: SatisfiesExpression, expression: Expression, type: TypeNode): SatisfiesExpression;
3793        createTemplateSpan(expression: Expression, literal: TemplateMiddle | TemplateTail): TemplateSpan;
3794        updateTemplateSpan(node: TemplateSpan, expression: Expression, literal: TemplateMiddle | TemplateTail): TemplateSpan;
3795        createSemicolonClassElement(): SemicolonClassElement;
3796        createBlock(statements: readonly Statement[], multiLine?: boolean): Block;
3797        updateBlock(node: Block, statements: readonly Statement[]): Block;
3798        createVariableStatement(modifiers: readonly Modifier[] | undefined, declarationList: VariableDeclarationList | readonly VariableDeclaration[]): VariableStatement;
3799        updateVariableStatement(node: VariableStatement, modifiers: readonly Modifier[] | undefined, declarationList: VariableDeclarationList): VariableStatement;
3800        createEmptyStatement(): EmptyStatement;
3801        createExpressionStatement(expression: Expression): ExpressionStatement;
3802        updateExpressionStatement(node: ExpressionStatement, expression: Expression): ExpressionStatement;
3803        createIfStatement(expression: Expression, thenStatement: Statement, elseStatement?: Statement): IfStatement;
3804        updateIfStatement(node: IfStatement, expression: Expression, thenStatement: Statement, elseStatement: Statement | undefined): IfStatement;
3805        createDoStatement(statement: Statement, expression: Expression): DoStatement;
3806        updateDoStatement(node: DoStatement, statement: Statement, expression: Expression): DoStatement;
3807        createWhileStatement(expression: Expression, statement: Statement): WhileStatement;
3808        updateWhileStatement(node: WhileStatement, expression: Expression, statement: Statement): WhileStatement;
3809        createForStatement(initializer: ForInitializer | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement): ForStatement;
3810        updateForStatement(node: ForStatement, initializer: ForInitializer | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement): ForStatement;
3811        createForInStatement(initializer: ForInitializer, expression: Expression, statement: Statement): ForInStatement;
3812        updateForInStatement(node: ForInStatement, initializer: ForInitializer, expression: Expression, statement: Statement): ForInStatement;
3813        createForOfStatement(awaitModifier: AwaitKeyword | undefined, initializer: ForInitializer, expression: Expression, statement: Statement): ForOfStatement;
3814        updateForOfStatement(node: ForOfStatement, awaitModifier: AwaitKeyword | undefined, initializer: ForInitializer, expression: Expression, statement: Statement): ForOfStatement;
3815        createContinueStatement(label?: string | Identifier): ContinueStatement;
3816        updateContinueStatement(node: ContinueStatement, label: Identifier | undefined): ContinueStatement;
3817        createBreakStatement(label?: string | Identifier): BreakStatement;
3818        updateBreakStatement(node: BreakStatement, label: Identifier | undefined): BreakStatement;
3819        createReturnStatement(expression?: Expression): ReturnStatement;
3820        updateReturnStatement(node: ReturnStatement, expression: Expression | undefined): ReturnStatement;
3821        createWithStatement(expression: Expression, statement: Statement): WithStatement;
3822        updateWithStatement(node: WithStatement, expression: Expression, statement: Statement): WithStatement;
3823        createSwitchStatement(expression: Expression, caseBlock: CaseBlock): SwitchStatement;
3824        updateSwitchStatement(node: SwitchStatement, expression: Expression, caseBlock: CaseBlock): SwitchStatement;
3825        createLabeledStatement(label: string | Identifier, statement: Statement): LabeledStatement;
3826        updateLabeledStatement(node: LabeledStatement, label: Identifier, statement: Statement): LabeledStatement;
3827        createThrowStatement(expression: Expression): ThrowStatement;
3828        updateThrowStatement(node: ThrowStatement, expression: Expression): ThrowStatement;
3829        createTryStatement(tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined): TryStatement;
3830        updateTryStatement(node: TryStatement, tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined): TryStatement;
3831        createDebuggerStatement(): DebuggerStatement;
3832        createVariableDeclaration(name: string | BindingName, exclamationToken?: ExclamationToken, type?: TypeNode, initializer?: Expression): VariableDeclaration;
3833        updateVariableDeclaration(node: VariableDeclaration, name: BindingName, exclamationToken: ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): VariableDeclaration;
3834        createVariableDeclarationList(declarations: readonly VariableDeclaration[], flags?: NodeFlags): VariableDeclarationList;
3835        updateVariableDeclarationList(node: VariableDeclarationList, declarations: readonly VariableDeclaration[]): VariableDeclarationList;
3836        createFunctionDeclaration(modifiers: readonly ModifierLike[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): FunctionDeclaration;
3837        updateFunctionDeclaration(node: FunctionDeclaration, modifiers: readonly ModifierLike[] | undefined, asteriskToken: AsteriskToken | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): FunctionDeclaration;
3838        createClassDeclaration(modifiers: readonly ModifierLike[] | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassDeclaration;
3839        updateClassDeclaration(node: ClassDeclaration, modifiers: readonly ModifierLike[] | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassDeclaration;
3840        createStructDeclaration(modifiers: readonly ModifierLike[] | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): StructDeclaration;
3841        updateStructDeclaration(node: StructDeclaration, modifiers: readonly ModifierLike[] | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): StructDeclaration;
3842        createInterfaceDeclaration(modifiers: readonly Modifier[] | undefined, name: string | Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly TypeElement[]): InterfaceDeclaration;
3843        updateInterfaceDeclaration(node: InterfaceDeclaration, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly TypeElement[]): InterfaceDeclaration;
3844        createTypeAliasDeclaration(modifiers: readonly Modifier[] | undefined, name: string | Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration;
3845        updateTypeAliasDeclaration(node: TypeAliasDeclaration, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration;
3846        createEnumDeclaration(modifiers: readonly Modifier[] | undefined, name: string | Identifier, members: readonly EnumMember[]): EnumDeclaration;
3847        updateEnumDeclaration(node: EnumDeclaration, modifiers: readonly Modifier[] | undefined, name: Identifier, members: readonly EnumMember[]): EnumDeclaration;
3848        createModuleDeclaration(modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined, flags?: NodeFlags): ModuleDeclaration;
3849        updateModuleDeclaration(node: ModuleDeclaration, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined): ModuleDeclaration;
3850        createModuleBlock(statements: readonly Statement[]): ModuleBlock;
3851        updateModuleBlock(node: ModuleBlock, statements: readonly Statement[]): ModuleBlock;
3852        createCaseBlock(clauses: readonly CaseOrDefaultClause[]): CaseBlock;
3853        updateCaseBlock(node: CaseBlock, clauses: readonly CaseOrDefaultClause[]): CaseBlock;
3854        createNamespaceExportDeclaration(name: string | Identifier): NamespaceExportDeclaration;
3855        updateNamespaceExportDeclaration(node: NamespaceExportDeclaration, name: Identifier): NamespaceExportDeclaration;
3856        createImportEqualsDeclaration(modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: string | Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration;
3857        updateImportEqualsDeclaration(node: ImportEqualsDeclaration, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration;
3858        createImportDeclaration(modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause?: AssertClause): ImportDeclaration;
3859        updateImportDeclaration(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration;
3860        createImportClause(isTypeOnly: boolean, name: Identifier | undefined, namedBindings: NamedImportBindings | undefined): ImportClause;
3861        updateImportClause(node: ImportClause, isTypeOnly: boolean, name: Identifier | undefined, namedBindings: NamedImportBindings | undefined): ImportClause;
3862        createAssertClause(elements: NodeArray<AssertEntry>, multiLine?: boolean): AssertClause;
3863        updateAssertClause(node: AssertClause, elements: NodeArray<AssertEntry>, multiLine?: boolean): AssertClause;
3864        createAssertEntry(name: AssertionKey, value: Expression): AssertEntry;
3865        updateAssertEntry(node: AssertEntry, name: AssertionKey, value: Expression): AssertEntry;
3866        createImportTypeAssertionContainer(clause: AssertClause, multiLine?: boolean): ImportTypeAssertionContainer;
3867        updateImportTypeAssertionContainer(node: ImportTypeAssertionContainer, clause: AssertClause, multiLine?: boolean): ImportTypeAssertionContainer;
3868        createNamespaceImport(name: Identifier): NamespaceImport;
3869        updateNamespaceImport(node: NamespaceImport, name: Identifier): NamespaceImport;
3870        createNamespaceExport(name: Identifier): NamespaceExport;
3871        updateNamespaceExport(node: NamespaceExport, name: Identifier): NamespaceExport;
3872        createNamedImports(elements: readonly ImportSpecifier[]): NamedImports;
3873        updateNamedImports(node: NamedImports, elements: readonly ImportSpecifier[]): NamedImports;
3874        createImportSpecifier(isTypeOnly: boolean, propertyName: Identifier | undefined, name: Identifier): ImportSpecifier;
3875        updateImportSpecifier(node: ImportSpecifier, isTypeOnly: boolean, propertyName: Identifier | undefined, name: Identifier): ImportSpecifier;
3876        createExportAssignment(modifiers: readonly Modifier[] | undefined, isExportEquals: boolean | undefined, expression: Expression): ExportAssignment;
3877        updateExportAssignment(node: ExportAssignment, modifiers: readonly Modifier[] | undefined, expression: Expression): ExportAssignment;
3878        createExportDeclaration(modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, exportClause: NamedExportBindings | undefined, moduleSpecifier?: Expression, assertClause?: AssertClause): ExportDeclaration;
3879        updateExportDeclaration(node: ExportDeclaration, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, exportClause: NamedExportBindings | undefined, moduleSpecifier: Expression | undefined, assertClause: AssertClause | undefined): ExportDeclaration;
3880        createNamedExports(elements: readonly ExportSpecifier[]): NamedExports;
3881        updateNamedExports(node: NamedExports, elements: readonly ExportSpecifier[]): NamedExports;
3882        createExportSpecifier(isTypeOnly: boolean, propertyName: string | Identifier | undefined, name: string | Identifier): ExportSpecifier;
3883        updateExportSpecifier(node: ExportSpecifier, isTypeOnly: boolean, propertyName: Identifier | undefined, name: Identifier): ExportSpecifier;
3884        createExternalModuleReference(expression: Expression): ExternalModuleReference;
3885        updateExternalModuleReference(node: ExternalModuleReference, expression: Expression): ExternalModuleReference;
3886        createJSDocAllType(): JSDocAllType;
3887        createJSDocUnknownType(): JSDocUnknownType;
3888        createJSDocNonNullableType(type: TypeNode, postfix?: boolean): JSDocNonNullableType;
3889        updateJSDocNonNullableType(node: JSDocNonNullableType, type: TypeNode): JSDocNonNullableType;
3890        createJSDocNullableType(type: TypeNode, postfix?: boolean): JSDocNullableType;
3891        updateJSDocNullableType(node: JSDocNullableType, type: TypeNode): JSDocNullableType;
3892        createJSDocOptionalType(type: TypeNode): JSDocOptionalType;
3893        updateJSDocOptionalType(node: JSDocOptionalType, type: TypeNode): JSDocOptionalType;
3894        createJSDocFunctionType(parameters: readonly ParameterDeclaration[], type: TypeNode | undefined): JSDocFunctionType;
3895        updateJSDocFunctionType(node: JSDocFunctionType, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined): JSDocFunctionType;
3896        createJSDocVariadicType(type: TypeNode): JSDocVariadicType;
3897        updateJSDocVariadicType(node: JSDocVariadicType, type: TypeNode): JSDocVariadicType;
3898        createJSDocNamepathType(type: TypeNode): JSDocNamepathType;
3899        updateJSDocNamepathType(node: JSDocNamepathType, type: TypeNode): JSDocNamepathType;
3900        createJSDocTypeExpression(type: TypeNode): JSDocTypeExpression;
3901        updateJSDocTypeExpression(node: JSDocTypeExpression, type: TypeNode): JSDocTypeExpression;
3902        createJSDocNameReference(name: EntityName | JSDocMemberName): JSDocNameReference;
3903        updateJSDocNameReference(node: JSDocNameReference, name: EntityName | JSDocMemberName): JSDocNameReference;
3904        createJSDocMemberName(left: EntityName | JSDocMemberName, right: Identifier): JSDocMemberName;
3905        updateJSDocMemberName(node: JSDocMemberName, left: EntityName | JSDocMemberName, right: Identifier): JSDocMemberName;
3906        createJSDocLink(name: EntityName | JSDocMemberName | undefined, text: string): JSDocLink;
3907        updateJSDocLink(node: JSDocLink, name: EntityName | JSDocMemberName | undefined, text: string): JSDocLink;
3908        createJSDocLinkCode(name: EntityName | JSDocMemberName | undefined, text: string): JSDocLinkCode;
3909        updateJSDocLinkCode(node: JSDocLinkCode, name: EntityName | JSDocMemberName | undefined, text: string): JSDocLinkCode;
3910        createJSDocLinkPlain(name: EntityName | JSDocMemberName | undefined, text: string): JSDocLinkPlain;
3911        updateJSDocLinkPlain(node: JSDocLinkPlain, name: EntityName | JSDocMemberName | undefined, text: string): JSDocLinkPlain;
3912        createJSDocTypeLiteral(jsDocPropertyTags?: readonly JSDocPropertyLikeTag[], isArrayType?: boolean): JSDocTypeLiteral;
3913        updateJSDocTypeLiteral(node: JSDocTypeLiteral, jsDocPropertyTags: readonly JSDocPropertyLikeTag[] | undefined, isArrayType: boolean | undefined): JSDocTypeLiteral;
3914        createJSDocSignature(typeParameters: readonly JSDocTemplateTag[] | undefined, parameters: readonly JSDocParameterTag[], type?: JSDocReturnTag): JSDocSignature;
3915        updateJSDocSignature(node: JSDocSignature, typeParameters: readonly JSDocTemplateTag[] | undefined, parameters: readonly JSDocParameterTag[], type: JSDocReturnTag | undefined): JSDocSignature;
3916        createJSDocTemplateTag(tagName: Identifier | undefined, constraint: JSDocTypeExpression | undefined, typeParameters: readonly TypeParameterDeclaration[], comment?: string | NodeArray<JSDocComment>): JSDocTemplateTag;
3917        updateJSDocTemplateTag(node: JSDocTemplateTag, tagName: Identifier | undefined, constraint: JSDocTypeExpression | undefined, typeParameters: readonly TypeParameterDeclaration[], comment: string | NodeArray<JSDocComment> | undefined): JSDocTemplateTag;
3918        createJSDocTypedefTag(tagName: Identifier | undefined, typeExpression?: JSDocTypeExpression | JSDocTypeLiteral, fullName?: Identifier | JSDocNamespaceDeclaration, comment?: string | NodeArray<JSDocComment>): JSDocTypedefTag;
3919        updateJSDocTypedefTag(node: JSDocTypedefTag, tagName: Identifier | undefined, typeExpression: JSDocTypeExpression | JSDocTypeLiteral | undefined, fullName: Identifier | JSDocNamespaceDeclaration | undefined, comment: string | NodeArray<JSDocComment> | undefined): JSDocTypedefTag;
3920        createJSDocParameterTag(tagName: Identifier | undefined, name: EntityName, isBracketed: boolean, typeExpression?: JSDocTypeExpression, isNameFirst?: boolean, comment?: string | NodeArray<JSDocComment>): JSDocParameterTag;
3921        updateJSDocParameterTag(node: JSDocParameterTag, tagName: Identifier | undefined, name: EntityName, isBracketed: boolean, typeExpression: JSDocTypeExpression | undefined, isNameFirst: boolean, comment: string | NodeArray<JSDocComment> | undefined): JSDocParameterTag;
3922        createJSDocPropertyTag(tagName: Identifier | undefined, name: EntityName, isBracketed: boolean, typeExpression?: JSDocTypeExpression, isNameFirst?: boolean, comment?: string | NodeArray<JSDocComment>): JSDocPropertyTag;
3923        updateJSDocPropertyTag(node: JSDocPropertyTag, tagName: Identifier | undefined, name: EntityName, isBracketed: boolean, typeExpression: JSDocTypeExpression | undefined, isNameFirst: boolean, comment: string | NodeArray<JSDocComment> | undefined): JSDocPropertyTag;
3924        createJSDocTypeTag(tagName: Identifier | undefined, typeExpression: JSDocTypeExpression, comment?: string | NodeArray<JSDocComment>): JSDocTypeTag;
3925        updateJSDocTypeTag(node: JSDocTypeTag, tagName: Identifier | undefined, typeExpression: JSDocTypeExpression, comment: string | NodeArray<JSDocComment> | undefined): JSDocTypeTag;
3926        createJSDocSeeTag(tagName: Identifier | undefined, nameExpression: JSDocNameReference | undefined, comment?: string | NodeArray<JSDocComment>): JSDocSeeTag;
3927        updateJSDocSeeTag(node: JSDocSeeTag, tagName: Identifier | undefined, nameExpression: JSDocNameReference | undefined, comment?: string | NodeArray<JSDocComment>): JSDocSeeTag;
3928        createJSDocReturnTag(tagName: Identifier | undefined, typeExpression?: JSDocTypeExpression, comment?: string | NodeArray<JSDocComment>): JSDocReturnTag;
3929        updateJSDocReturnTag(node: JSDocReturnTag, tagName: Identifier | undefined, typeExpression: JSDocTypeExpression | undefined, comment: string | NodeArray<JSDocComment> | undefined): JSDocReturnTag;
3930        createJSDocThisTag(tagName: Identifier | undefined, typeExpression: JSDocTypeExpression, comment?: string | NodeArray<JSDocComment>): JSDocThisTag;
3931        updateJSDocThisTag(node: JSDocThisTag, tagName: Identifier | undefined, typeExpression: JSDocTypeExpression | undefined, comment: string | NodeArray<JSDocComment> | undefined): JSDocThisTag;
3932        createJSDocEnumTag(tagName: Identifier | undefined, typeExpression: JSDocTypeExpression, comment?: string | NodeArray<JSDocComment>): JSDocEnumTag;
3933        updateJSDocEnumTag(node: JSDocEnumTag, tagName: Identifier | undefined, typeExpression: JSDocTypeExpression, comment: string | NodeArray<JSDocComment> | undefined): JSDocEnumTag;
3934        createJSDocCallbackTag(tagName: Identifier | undefined, typeExpression: JSDocSignature, fullName?: Identifier | JSDocNamespaceDeclaration, comment?: string | NodeArray<JSDocComment>): JSDocCallbackTag;
3935        updateJSDocCallbackTag(node: JSDocCallbackTag, tagName: Identifier | undefined, typeExpression: JSDocSignature, fullName: Identifier | JSDocNamespaceDeclaration | undefined, comment: string | NodeArray<JSDocComment> | undefined): JSDocCallbackTag;
3936        createJSDocAugmentsTag(tagName: Identifier | undefined, className: JSDocAugmentsTag["class"], comment?: string | NodeArray<JSDocComment>): JSDocAugmentsTag;
3937        updateJSDocAugmentsTag(node: JSDocAugmentsTag, tagName: Identifier | undefined, className: JSDocAugmentsTag["class"], comment: string | NodeArray<JSDocComment> | undefined): JSDocAugmentsTag;
3938        createJSDocImplementsTag(tagName: Identifier | undefined, className: JSDocImplementsTag["class"], comment?: string | NodeArray<JSDocComment>): JSDocImplementsTag;
3939        updateJSDocImplementsTag(node: JSDocImplementsTag, tagName: Identifier | undefined, className: JSDocImplementsTag["class"], comment: string | NodeArray<JSDocComment> | undefined): JSDocImplementsTag;
3940        createJSDocAuthorTag(tagName: Identifier | undefined, comment?: string | NodeArray<JSDocComment>): JSDocAuthorTag;
3941        updateJSDocAuthorTag(node: JSDocAuthorTag, tagName: Identifier | undefined, comment: string | NodeArray<JSDocComment> | undefined): JSDocAuthorTag;
3942        createJSDocClassTag(tagName: Identifier | undefined, comment?: string | NodeArray<JSDocComment>): JSDocClassTag;
3943        updateJSDocClassTag(node: JSDocClassTag, tagName: Identifier | undefined, comment: string | NodeArray<JSDocComment> | undefined): JSDocClassTag;
3944        createJSDocPublicTag(tagName: Identifier | undefined, comment?: string | NodeArray<JSDocComment>): JSDocPublicTag;
3945        updateJSDocPublicTag(node: JSDocPublicTag, tagName: Identifier | undefined, comment: string | NodeArray<JSDocComment> | undefined): JSDocPublicTag;
3946        createJSDocPrivateTag(tagName: Identifier | undefined, comment?: string | NodeArray<JSDocComment>): JSDocPrivateTag;
3947        updateJSDocPrivateTag(node: JSDocPrivateTag, tagName: Identifier | undefined, comment: string | NodeArray<JSDocComment> | undefined): JSDocPrivateTag;
3948        createJSDocProtectedTag(tagName: Identifier | undefined, comment?: string | NodeArray<JSDocComment>): JSDocProtectedTag;
3949        updateJSDocProtectedTag(node: JSDocProtectedTag, tagName: Identifier | undefined, comment: string | NodeArray<JSDocComment> | undefined): JSDocProtectedTag;
3950        createJSDocReadonlyTag(tagName: Identifier | undefined, comment?: string | NodeArray<JSDocComment>): JSDocReadonlyTag;
3951        updateJSDocReadonlyTag(node: JSDocReadonlyTag, tagName: Identifier | undefined, comment: string | NodeArray<JSDocComment> | undefined): JSDocReadonlyTag;
3952        createJSDocUnknownTag(tagName: Identifier, comment?: string | NodeArray<JSDocComment>): JSDocUnknownTag;
3953        updateJSDocUnknownTag(node: JSDocUnknownTag, tagName: Identifier, comment: string | NodeArray<JSDocComment> | undefined): JSDocUnknownTag;
3954        createJSDocDeprecatedTag(tagName: Identifier, comment?: string | NodeArray<JSDocComment>): JSDocDeprecatedTag;
3955        updateJSDocDeprecatedTag(node: JSDocDeprecatedTag, tagName: Identifier, comment?: string | NodeArray<JSDocComment>): JSDocDeprecatedTag;
3956        createJSDocOverrideTag(tagName: Identifier, comment?: string | NodeArray<JSDocComment>): JSDocOverrideTag;
3957        updateJSDocOverrideTag(node: JSDocOverrideTag, tagName: Identifier, comment?: string | NodeArray<JSDocComment>): JSDocOverrideTag;
3958        createJSDocText(text: string): JSDocText;
3959        updateJSDocText(node: JSDocText, text: string): JSDocText;
3960        createJSDocComment(comment?: string | NodeArray<JSDocComment> | undefined, tags?: readonly JSDocTag[] | undefined): JSDoc;
3961        updateJSDocComment(node: JSDoc, comment: string | NodeArray<JSDocComment> | undefined, tags: readonly JSDocTag[] | undefined): JSDoc;
3962        createJsxElement(openingElement: JsxOpeningElement, children: readonly JsxChild[], closingElement: JsxClosingElement): JsxElement;
3963        updateJsxElement(node: JsxElement, openingElement: JsxOpeningElement, children: readonly JsxChild[], closingElement: JsxClosingElement): JsxElement;
3964        createJsxSelfClosingElement(tagName: JsxTagNameExpression, typeArguments: readonly TypeNode[] | undefined, attributes: JsxAttributes): JsxSelfClosingElement;
3965        updateJsxSelfClosingElement(node: JsxSelfClosingElement, tagName: JsxTagNameExpression, typeArguments: readonly TypeNode[] | undefined, attributes: JsxAttributes): JsxSelfClosingElement;
3966        createJsxOpeningElement(tagName: JsxTagNameExpression, typeArguments: readonly TypeNode[] | undefined, attributes: JsxAttributes): JsxOpeningElement;
3967        updateJsxOpeningElement(node: JsxOpeningElement, tagName: JsxTagNameExpression, typeArguments: readonly TypeNode[] | undefined, attributes: JsxAttributes): JsxOpeningElement;
3968        createJsxClosingElement(tagName: JsxTagNameExpression): JsxClosingElement;
3969        updateJsxClosingElement(node: JsxClosingElement, tagName: JsxTagNameExpression): JsxClosingElement;
3970        createJsxFragment(openingFragment: JsxOpeningFragment, children: readonly JsxChild[], closingFragment: JsxClosingFragment): JsxFragment;
3971        createJsxText(text: string, containsOnlyTriviaWhiteSpaces?: boolean): JsxText;
3972        updateJsxText(node: JsxText, text: string, containsOnlyTriviaWhiteSpaces?: boolean): JsxText;
3973        createJsxOpeningFragment(): JsxOpeningFragment;
3974        createJsxJsxClosingFragment(): JsxClosingFragment;
3975        updateJsxFragment(node: JsxFragment, openingFragment: JsxOpeningFragment, children: readonly JsxChild[], closingFragment: JsxClosingFragment): JsxFragment;
3976        createJsxAttribute(name: Identifier, initializer: JsxAttributeValue | undefined): JsxAttribute;
3977        updateJsxAttribute(node: JsxAttribute, name: Identifier, initializer: JsxAttributeValue | undefined): JsxAttribute;
3978        createJsxAttributes(properties: readonly JsxAttributeLike[]): JsxAttributes;
3979        updateJsxAttributes(node: JsxAttributes, properties: readonly JsxAttributeLike[]): JsxAttributes;
3980        createJsxSpreadAttribute(expression: Expression): JsxSpreadAttribute;
3981        updateJsxSpreadAttribute(node: JsxSpreadAttribute, expression: Expression): JsxSpreadAttribute;
3982        createJsxExpression(dotDotDotToken: DotDotDotToken | undefined, expression: Expression | undefined): JsxExpression;
3983        updateJsxExpression(node: JsxExpression, expression: Expression | undefined): JsxExpression;
3984        createCaseClause(expression: Expression, statements: readonly Statement[]): CaseClause;
3985        updateCaseClause(node: CaseClause, expression: Expression, statements: readonly Statement[]): CaseClause;
3986        createDefaultClause(statements: readonly Statement[]): DefaultClause;
3987        updateDefaultClause(node: DefaultClause, statements: readonly Statement[]): DefaultClause;
3988        createHeritageClause(token: HeritageClause["token"], types: readonly ExpressionWithTypeArguments[]): HeritageClause;
3989        updateHeritageClause(node: HeritageClause, types: readonly ExpressionWithTypeArguments[]): HeritageClause;
3990        createCatchClause(variableDeclaration: string | BindingName | VariableDeclaration | undefined, block: Block): CatchClause;
3991        updateCatchClause(node: CatchClause, variableDeclaration: VariableDeclaration | undefined, block: Block): CatchClause;
3992        createPropertyAssignment(name: string | PropertyName, initializer: Expression): PropertyAssignment;
3993        updatePropertyAssignment(node: PropertyAssignment, name: PropertyName, initializer: Expression): PropertyAssignment;
3994        createShorthandPropertyAssignment(name: string | Identifier, objectAssignmentInitializer?: Expression): ShorthandPropertyAssignment;
3995        updateShorthandPropertyAssignment(node: ShorthandPropertyAssignment, name: Identifier, objectAssignmentInitializer: Expression | undefined): ShorthandPropertyAssignment;
3996        createSpreadAssignment(expression: Expression): SpreadAssignment;
3997        updateSpreadAssignment(node: SpreadAssignment, expression: Expression): SpreadAssignment;
3998        createEnumMember(name: string | PropertyName, initializer?: Expression): EnumMember;
3999        updateEnumMember(node: EnumMember, name: PropertyName, initializer: Expression | undefined): EnumMember;
4000        createSourceFile(statements: readonly Statement[], endOfFileToken: EndOfFileToken, flags: NodeFlags): SourceFile;
4001        updateSourceFile(node: SourceFile, statements: readonly Statement[], isDeclarationFile?: boolean, referencedFiles?: readonly FileReference[], typeReferences?: readonly FileReference[], hasNoDefaultLib?: boolean, libReferences?: readonly FileReference[]): SourceFile;
4002        createNotEmittedStatement(original: Node): NotEmittedStatement;
4003        createPartiallyEmittedExpression(expression: Expression, original?: Node): PartiallyEmittedExpression;
4004        updatePartiallyEmittedExpression(node: PartiallyEmittedExpression, expression: Expression): PartiallyEmittedExpression;
4005        createCommaListExpression(elements: readonly Expression[]): CommaListExpression;
4006        updateCommaListExpression(node: CommaListExpression, elements: readonly Expression[]): CommaListExpression;
4007        createBundle(sourceFiles: readonly SourceFile[], prepends?: readonly (UnparsedSource | InputFiles)[]): Bundle;
4008        updateBundle(node: Bundle, sourceFiles: readonly SourceFile[], prepends?: readonly (UnparsedSource | InputFiles)[]): Bundle;
4009        createComma(left: Expression, right: Expression): BinaryExpression;
4010        createAssignment(left: ObjectLiteralExpression | ArrayLiteralExpression, right: Expression): DestructuringAssignment;
4011        createAssignment(left: Expression, right: Expression): AssignmentExpression<EqualsToken>;
4012        createLogicalOr(left: Expression, right: Expression): BinaryExpression;
4013        createLogicalAnd(left: Expression, right: Expression): BinaryExpression;
4014        createBitwiseOr(left: Expression, right: Expression): BinaryExpression;
4015        createBitwiseXor(left: Expression, right: Expression): BinaryExpression;
4016        createBitwiseAnd(left: Expression, right: Expression): BinaryExpression;
4017        createStrictEquality(left: Expression, right: Expression): BinaryExpression;
4018        createStrictInequality(left: Expression, right: Expression): BinaryExpression;
4019        createEquality(left: Expression, right: Expression): BinaryExpression;
4020        createInequality(left: Expression, right: Expression): BinaryExpression;
4021        createLessThan(left: Expression, right: Expression): BinaryExpression;
4022        createLessThanEquals(left: Expression, right: Expression): BinaryExpression;
4023        createGreaterThan(left: Expression, right: Expression): BinaryExpression;
4024        createGreaterThanEquals(left: Expression, right: Expression): BinaryExpression;
4025        createLeftShift(left: Expression, right: Expression): BinaryExpression;
4026        createRightShift(left: Expression, right: Expression): BinaryExpression;
4027        createUnsignedRightShift(left: Expression, right: Expression): BinaryExpression;
4028        createAdd(left: Expression, right: Expression): BinaryExpression;
4029        createSubtract(left: Expression, right: Expression): BinaryExpression;
4030        createMultiply(left: Expression, right: Expression): BinaryExpression;
4031        createDivide(left: Expression, right: Expression): BinaryExpression;
4032        createModulo(left: Expression, right: Expression): BinaryExpression;
4033        createExponent(left: Expression, right: Expression): BinaryExpression;
4034        createPrefixPlus(operand: Expression): PrefixUnaryExpression;
4035        createPrefixMinus(operand: Expression): PrefixUnaryExpression;
4036        createPrefixIncrement(operand: Expression): PrefixUnaryExpression;
4037        createPrefixDecrement(operand: Expression): PrefixUnaryExpression;
4038        createBitwiseNot(operand: Expression): PrefixUnaryExpression;
4039        createLogicalNot(operand: Expression): PrefixUnaryExpression;
4040        createPostfixIncrement(operand: Expression): PostfixUnaryExpression;
4041        createPostfixDecrement(operand: Expression): PostfixUnaryExpression;
4042        createImmediatelyInvokedFunctionExpression(statements: readonly Statement[]): CallExpression;
4043        createImmediatelyInvokedFunctionExpression(statements: readonly Statement[], param: ParameterDeclaration, paramValue: Expression): CallExpression;
4044        createImmediatelyInvokedArrowFunction(statements: readonly Statement[]): CallExpression;
4045        createImmediatelyInvokedArrowFunction(statements: readonly Statement[], param: ParameterDeclaration, paramValue: Expression): CallExpression;
4046        createVoidZero(): VoidExpression;
4047        createExportDefault(expression: Expression): ExportAssignment;
4048        createExternalModuleExport(exportName: Identifier): ExportDeclaration;
4049        restoreOuterExpressions(outerExpression: Expression | undefined, innerExpression: Expression, kinds?: OuterExpressionKinds): Expression;
4050    }
4051    export interface CoreTransformationContext {
4052        readonly factory: NodeFactory;
4053        /** Gets the compiler options supplied to the transformer. */
4054        getCompilerOptions(): CompilerOptions;
4055        /** Starts a new lexical environment. */
4056        startLexicalEnvironment(): void;
4057        /** Suspends the current lexical environment, usually after visiting a parameter list. */
4058        suspendLexicalEnvironment(): void;
4059        /** Resumes a suspended lexical environment, usually before visiting a function body. */
4060        resumeLexicalEnvironment(): void;
4061        /** Ends a lexical environment, returning any declarations. */
4062        endLexicalEnvironment(): Statement[] | undefined;
4063        /** Hoists a function declaration to the containing scope. */
4064        hoistFunctionDeclaration(node: FunctionDeclaration): void;
4065        /** Hoists a variable declaration to the containing scope. */
4066        hoistVariableDeclaration(node: Identifier): void;
4067    }
4068    export interface TransformationContext extends CoreTransformationContext {
4069        /** Records a request for a non-scoped emit helper in the current context. */
4070        requestEmitHelper(helper: EmitHelper): void;
4071        /** Gets and resets the requested non-scoped emit helpers. */
4072        readEmitHelpers(): EmitHelper[] | undefined;
4073        /** Enables expression substitutions in the pretty printer for the provided SyntaxKind. */
4074        enableSubstitution(kind: SyntaxKind): void;
4075        /** Determines whether expression substitutions are enabled for the provided node. */
4076        isSubstitutionEnabled(node: Node): boolean;
4077        /**
4078         * Hook used by transformers to substitute expressions just before they
4079         * are emitted by the pretty printer.
4080         *
4081         * NOTE: Transformation hooks should only be modified during `Transformer` initialization,
4082         * before returning the `NodeTransformer` callback.
4083         */
4084        onSubstituteNode: (hint: EmitHint, node: Node) => Node;
4085        /**
4086         * Enables before/after emit notifications in the pretty printer for the provided
4087         * SyntaxKind.
4088         */
4089        enableEmitNotification(kind: SyntaxKind): void;
4090        /**
4091         * Determines whether before/after emit notifications should be raised in the pretty
4092         * printer when it emits a node.
4093         */
4094        isEmitNotificationEnabled(node: Node): boolean;
4095        /**
4096         * Hook used to allow transformers to capture state before or after
4097         * the printer emits a node.
4098         *
4099         * NOTE: Transformation hooks should only be modified during `Transformer` initialization,
4100         * before returning the `NodeTransformer` callback.
4101         */
4102        onEmitNode: (hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) => void;
4103    }
4104    export interface TransformationResult<T extends Node> {
4105        /** Gets the transformed source files. */
4106        transformed: T[];
4107        /** Gets diagnostics for the transformation. */
4108        diagnostics?: DiagnosticWithLocation[];
4109        /**
4110         * Gets a substitute for a node, if one is available; otherwise, returns the original node.
4111         *
4112         * @param hint A hint as to the intended usage of the node.
4113         * @param node The node to substitute.
4114         */
4115        substituteNode(hint: EmitHint, node: Node): Node;
4116        /**
4117         * Emits a node with possible notification.
4118         *
4119         * @param hint A hint as to the intended usage of the node.
4120         * @param node The node to emit.
4121         * @param emitCallback A callback used to emit the node.
4122         */
4123        emitNodeWithNotification(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void): void;
4124        /**
4125         * Indicates if a given node needs an emit notification
4126         *
4127         * @param node The node to emit.
4128         */
4129        isEmitNotificationEnabled?(node: Node): boolean;
4130        /**
4131         * Clean up EmitNode entries on any parse-tree nodes.
4132         */
4133        dispose(): void;
4134    }
4135    /**
4136     * A function that is used to initialize and return a `Transformer` callback, which in turn
4137     * will be used to transform one or more nodes.
4138     */
4139    export type TransformerFactory<T extends Node> = (context: TransformationContext) => Transformer<T>;
4140    /**
4141     * A function that transforms a node.
4142     */
4143    export type Transformer<T extends Node> = (node: T) => T;
4144    /**
4145     * A function that accepts and possibly transforms a node.
4146     */
4147    export type Visitor = (node: Node) => VisitResult<Node>;
4148    export interface NodeVisitor {
4149        <T extends Node>(nodes: T, visitor: Visitor | undefined, test?: (node: Node) => boolean, lift?: (node: readonly Node[]) => T): T;
4150        <T extends Node>(nodes: T | undefined, visitor: Visitor | undefined, test?: (node: Node) => boolean, lift?: (node: readonly Node[]) => T): T | undefined;
4151    }
4152    export interface NodesVisitor {
4153        <T extends Node>(nodes: NodeArray<T>, visitor: Visitor | undefined, test?: (node: Node) => boolean, start?: number, count?: number): NodeArray<T>;
4154        <T extends Node>(nodes: NodeArray<T> | undefined, visitor: Visitor | undefined, test?: (node: Node) => boolean, start?: number, count?: number): NodeArray<T> | undefined;
4155    }
4156    export type VisitResult<T extends Node> = T | readonly T[] | undefined;
4157    export interface Printer {
4158        /**
4159         * Print a node and its subtree as-is, without any emit transformations.
4160         * @param hint A value indicating the purpose of a node. This is primarily used to
4161         * distinguish between an `Identifier` used in an expression position, versus an
4162         * `Identifier` used as an `IdentifierName` as part of a declaration. For most nodes you
4163         * should just pass `Unspecified`.
4164         * @param node The node to print. The node and its subtree are printed as-is, without any
4165         * emit transformations.
4166         * @param sourceFile A source file that provides context for the node. The source text of
4167         * the file is used to emit the original source content for literals and identifiers, while
4168         * the identifiers of the source file are used when generating unique names to avoid
4169         * collisions.
4170         */
4171        printNode(hint: EmitHint, node: Node, sourceFile: SourceFile): string;
4172        /**
4173         * Prints a list of nodes using the given format flags
4174         */
4175        printList<T extends Node>(format: ListFormat, list: NodeArray<T>, sourceFile: SourceFile): string;
4176        /**
4177         * Prints a source file as-is, without any emit transformations.
4178         */
4179        printFile(sourceFile: SourceFile): string;
4180        /**
4181         * Prints a bundle of source files as-is, without any emit transformations.
4182         */
4183        printBundle(bundle: Bundle): string;
4184        writeFile(sourceFile: SourceFile, writer: EmitTextWriter, sourceMapGenerator: SourceMapGenerator | undefined): void;
4185    }
4186    export interface PrintHandlers {
4187        /**
4188         * A hook used by the Printer when generating unique names to avoid collisions with
4189         * globally defined names that exist outside of the current source file.
4190         */
4191        hasGlobalName?(name: string): boolean;
4192        /**
4193         * A hook used by the Printer to provide notifications prior to emitting a node. A
4194         * compatible implementation **must** invoke `emitCallback` with the provided `hint` and
4195         * `node` values.
4196         * @param hint A hint indicating the intended purpose of the node.
4197         * @param node The node to emit.
4198         * @param emitCallback A callback that, when invoked, will emit the node.
4199         * @example
4200         * ```ts
4201         * var printer = createPrinter(printerOptions, {
4202         *   onEmitNode(hint, node, emitCallback) {
4203         *     // set up or track state prior to emitting the node...
4204         *     emitCallback(hint, node);
4205         *     // restore state after emitting the node...
4206         *   }
4207         * });
4208         * ```
4209         */
4210        onEmitNode?(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void): void;
4211        /**
4212         * A hook used to check if an emit notification is required for a node.
4213         * @param node The node to emit.
4214         */
4215        isEmitNotificationEnabled?(node: Node): boolean;
4216        /**
4217         * A hook used by the Printer to perform just-in-time substitution of a node. This is
4218         * primarily used by node transformations that need to substitute one node for another,
4219         * such as replacing `myExportedVar` with `exports.myExportedVar`.
4220         * @param hint A hint indicating the intended purpose of the node.
4221         * @param node The node to emit.
4222         * @example
4223         * ```ts
4224         * var printer = createPrinter(printerOptions, {
4225         *   substituteNode(hint, node) {
4226         *     // perform substitution if necessary...
4227         *     return node;
4228         *   }
4229         * });
4230         * ```
4231         */
4232        substituteNode?(hint: EmitHint, node: Node): Node;
4233    }
4234    export interface PrinterOptions {
4235        removeComments?: boolean;
4236        newLine?: NewLineKind;
4237        omitTrailingSemicolon?: boolean;
4238        noEmitHelpers?: boolean;
4239        sourceMap?: boolean;
4240        inlineSourceMap?: boolean;
4241        inlineSources?: boolean;
4242    }
4243    export interface RawSourceMap {
4244        version: 3;
4245        file: string;
4246        sourceRoot?: string | null;
4247        sources: string[];
4248        sourcesContent?: (string | null)[] | null;
4249        mappings: string;
4250        names?: string[] | null;
4251    }
4252    /**
4253     * Generates a source map.
4254     */
4255    export interface SourceMapGenerator {
4256        getSources(): readonly string[];
4257        /**
4258         * Adds a source to the source map.
4259         */
4260        addSource(fileName: string): number;
4261        /**
4262         * Set the content for a source.
4263         */
4264        setSourceContent(sourceIndex: number, content: string | null): void;
4265        /**
4266         * Adds a name.
4267         */
4268        addName(name: string): number;
4269        /**
4270         * Adds a mapping without source information.
4271         */
4272        addMapping(generatedLine: number, generatedCharacter: number): void;
4273        /**
4274         * Adds a mapping with source information.
4275         */
4276        addMapping(generatedLine: number, generatedCharacter: number, sourceIndex: number, sourceLine: number, sourceCharacter: number, nameIndex?: number): void;
4277        /**
4278         * Appends a source map.
4279         */
4280        appendSourceMap(generatedLine: number, generatedCharacter: number, sourceMap: RawSourceMap, sourceMapPath: string, start?: LineAndCharacter, end?: LineAndCharacter): void;
4281        /**
4282         * Gets the source map as a `RawSourceMap` object.
4283         */
4284        toJSON(): RawSourceMap;
4285        /**
4286         * Gets the string representation of the source map.
4287         */
4288        toString(): string;
4289    }
4290    export interface EmitTextWriter extends SymbolWriter {
4291        write(s: string): void;
4292        writeTrailingSemicolon(text: string): void;
4293        writeComment(text: string): void;
4294        getText(): string;
4295        rawWrite(s: string): void;
4296        writeLiteral(s: string): void;
4297        getTextPos(): number;
4298        getLine(): number;
4299        getColumn(): number;
4300        getIndent(): number;
4301        isAtStartOfLine(): boolean;
4302        hasTrailingComment(): boolean;
4303        hasTrailingWhitespace(): boolean;
4304        getTextPosWithWriteLine?(): number;
4305        nonEscapingWrite?(text: string): void;
4306    }
4307    export interface GetEffectiveTypeRootsHost {
4308        directoryExists?(directoryName: string): boolean;
4309        getCurrentDirectory?(): string;
4310    }
4311    export interface ModuleSpecifierResolutionHost {
4312        useCaseSensitiveFileNames?(): boolean;
4313        fileExists(path: string): boolean;
4314        getCurrentDirectory(): string;
4315        directoryExists?(path: string): boolean;
4316        readFile?(path: string): string | undefined;
4317        realpath?(path: string): string;
4318        getModuleSpecifierCache?(): ModuleSpecifierCache;
4319        getPackageJsonInfoCache?(): PackageJsonInfoCache | undefined;
4320        getGlobalTypingsCacheLocation?(): string | undefined;
4321        getNearestAncestorDirectoryWithPackageJson?(fileName: string, rootDir?: string): string | undefined;
4322        readonly redirectTargetsMap: RedirectTargetsMap;
4323        getProjectReferenceRedirect(fileName: string): string | undefined;
4324        isSourceOfProjectReferenceRedirect(fileName: string): boolean;
4325    }
4326    export interface ModulePath {
4327        path: string;
4328        isInNodeModules: boolean;
4329        isRedirect: boolean;
4330    }
4331    export interface ResolvedModuleSpecifierInfo {
4332        modulePaths: readonly ModulePath[] | undefined;
4333        moduleSpecifiers: readonly string[] | undefined;
4334        isBlockedByPackageJsonDependencies: boolean | undefined;
4335    }
4336    export interface ModuleSpecifierOptions {
4337        overrideImportMode?: SourceFile["impliedNodeFormat"];
4338    }
4339    export interface ModuleSpecifierCache {
4340        get(fromFileName: Path, toFileName: Path, preferences: UserPreferences, options: ModuleSpecifierOptions): Readonly<ResolvedModuleSpecifierInfo> | undefined;
4341        set(fromFileName: Path, toFileName: Path, preferences: UserPreferences, options: ModuleSpecifierOptions, modulePaths: readonly ModulePath[], moduleSpecifiers: readonly string[]): void;
4342        setBlockedByPackageJsonDependencies(fromFileName: Path, toFileName: Path, preferences: UserPreferences, options: ModuleSpecifierOptions, isBlockedByPackageJsonDependencies: boolean): void;
4343        setModulePaths(fromFileName: Path, toFileName: Path, preferences: UserPreferences, options: ModuleSpecifierOptions, modulePaths: readonly ModulePath[]): void;
4344        clear(): void;
4345        count(): number;
4346    }
4347    export interface SymbolTracker {
4348        trackSymbol?(symbol: Symbol, enclosingDeclaration: Node | undefined, meaning: SymbolFlags): boolean;
4349        reportInaccessibleThisError?(): void;
4350        reportPrivateInBaseOfClassExpression?(propertyName: string): void;
4351        reportInaccessibleUniqueSymbolError?(): void;
4352        reportCyclicStructureError?(): void;
4353        reportLikelyUnsafeImportRequiredError?(specifier: string): void;
4354        reportTruncationError?(): void;
4355        moduleResolverHost?: ModuleSpecifierResolutionHost & {
4356            getCommonSourceDirectory(): string;
4357        };
4358        trackReferencedAmbientModule?(decl: ModuleDeclaration, symbol: Symbol): void;
4359        trackExternalModuleSymbolOfImportTypeNode?(symbol: Symbol): void;
4360        reportNonlocalAugmentation?(containingFile: SourceFile, parentSymbol: Symbol, augmentingSymbol: Symbol): void;
4361        reportNonSerializableProperty?(propertyName: string): void;
4362        reportImportTypeNodeResolutionModeOverride?(): void;
4363    }
4364    export interface TextSpan {
4365        start: number;
4366        length: number;
4367    }
4368    export interface TextChangeRange {
4369        span: TextSpan;
4370        newLength: number;
4371    }
4372    export interface SyntaxList extends Node {
4373        kind: SyntaxKind.SyntaxList;
4374        _children: Node[];
4375    }
4376    export enum ListFormat {
4377        None = 0,
4378        SingleLine = 0,
4379        MultiLine = 1,
4380        PreserveLines = 2,
4381        LinesMask = 3,
4382        NotDelimited = 0,
4383        BarDelimited = 4,
4384        AmpersandDelimited = 8,
4385        CommaDelimited = 16,
4386        AsteriskDelimited = 32,
4387        DelimitersMask = 60,
4388        AllowTrailingComma = 64,
4389        Indented = 128,
4390        SpaceBetweenBraces = 256,
4391        SpaceBetweenSiblings = 512,
4392        Braces = 1024,
4393        Parenthesis = 2048,
4394        AngleBrackets = 4096,
4395        SquareBrackets = 8192,
4396        BracketsMask = 15360,
4397        OptionalIfUndefined = 16384,
4398        OptionalIfEmpty = 32768,
4399        Optional = 49152,
4400        PreferNewLine = 65536,
4401        NoTrailingNewLine = 131072,
4402        NoInterveningComments = 262144,
4403        NoSpaceIfEmpty = 524288,
4404        SingleElement = 1048576,
4405        SpaceAfterList = 2097152,
4406        Modifiers = 2359808,
4407        HeritageClauses = 512,
4408        SingleLineTypeLiteralMembers = 768,
4409        MultiLineTypeLiteralMembers = 32897,
4410        SingleLineTupleTypeElements = 528,
4411        MultiLineTupleTypeElements = 657,
4412        UnionTypeConstituents = 516,
4413        IntersectionTypeConstituents = 520,
4414        ObjectBindingPatternElements = 525136,
4415        ArrayBindingPatternElements = 524880,
4416        ObjectLiteralExpressionProperties = 526226,
4417        ImportClauseEntries = 526226,
4418        ArrayLiteralExpressionElements = 8914,
4419        CommaListElements = 528,
4420        CallExpressionArguments = 2576,
4421        NewExpressionArguments = 18960,
4422        TemplateExpressionSpans = 262144,
4423        SingleLineBlockStatements = 768,
4424        MultiLineBlockStatements = 129,
4425        VariableDeclarationList = 528,
4426        SingleLineFunctionBodyStatements = 768,
4427        MultiLineFunctionBodyStatements = 1,
4428        ClassHeritageClauses = 0,
4429        ClassMembers = 129,
4430        InterfaceMembers = 129,
4431        EnumMembers = 145,
4432        CaseBlockClauses = 129,
4433        NamedImportsOrExportsElements = 525136,
4434        JsxElementOrFragmentChildren = 262144,
4435        JsxElementAttributes = 262656,
4436        CaseOrDefaultClauseStatements = 163969,
4437        HeritageClauseTypes = 528,
4438        SourceFileStatements = 131073,
4439        Decorators = 2146305,
4440        TypeArguments = 53776,
4441        TypeParameters = 53776,
4442        Parameters = 2576,
4443        IndexSignatureParameters = 8848,
4444        JSDocComment = 33
4445    }
4446    export interface UserPreferences {
4447        readonly disableSuggestions?: boolean;
4448        readonly quotePreference?: "auto" | "double" | "single";
4449        readonly includeCompletionsForModuleExports?: boolean;
4450        readonly includeCompletionsForImportStatements?: boolean;
4451        readonly includeCompletionsWithSnippetText?: boolean;
4452        readonly includeAutomaticOptionalChainCompletions?: boolean;
4453        readonly includeCompletionsWithInsertText?: boolean;
4454        readonly includeCompletionsWithClassMemberSnippets?: boolean;
4455        readonly includeCompletionsWithObjectLiteralMethodSnippets?: boolean;
4456        readonly useLabelDetailsInCompletionEntries?: boolean;
4457        readonly allowIncompleteCompletions?: boolean;
4458        readonly importModuleSpecifierPreference?: "shortest" | "project-relative" | "relative" | "non-relative";
4459        /** Determines whether we import `foo/index.ts` as "foo", "foo/index", or "foo/index.js" */
4460        readonly importModuleSpecifierEnding?: "auto" | "minimal" | "index" | "js";
4461        readonly allowTextChangesInNewFiles?: boolean;
4462        readonly providePrefixAndSuffixTextForRename?: boolean;
4463        readonly includePackageJsonAutoImports?: "auto" | "on" | "off";
4464        readonly provideRefactorNotApplicableReason?: boolean;
4465        readonly jsxAttributeCompletionStyle?: "auto" | "braces" | "none";
4466        readonly includeInlayParameterNameHints?: "none" | "literals" | "all";
4467        readonly includeInlayParameterNameHintsWhenArgumentMatchesName?: boolean;
4468        readonly includeInlayFunctionParameterTypeHints?: boolean;
4469        readonly includeInlayVariableTypeHints?: boolean;
4470        readonly includeInlayVariableTypeHintsWhenTypeMatchesName?: boolean;
4471        readonly includeInlayPropertyDeclarationTypeHints?: boolean;
4472        readonly includeInlayFunctionLikeReturnTypeHints?: boolean;
4473        readonly includeInlayEnumMemberValueHints?: boolean;
4474        readonly allowRenameOfImportPath?: boolean;
4475        readonly autoImportFileExcludePatterns?: string[];
4476    }
4477    /** Represents a bigint literal value without requiring bigint support */
4478    export interface PseudoBigInt {
4479        negative: boolean;
4480        base10Value: string;
4481    }
4482    export {};
4483}
4484declare function setTimeout(handler: (...args: any[]) => void, timeout: number): any;
4485declare function clearTimeout(handle: any): void;
4486declare namespace ts {
4487    export enum FileWatcherEventKind {
4488        Created = 0,
4489        Changed = 1,
4490        Deleted = 2
4491    }
4492    export type FileWatcherCallback = (fileName: string, eventKind: FileWatcherEventKind, modifiedTime?: Date) => void;
4493    export type DirectoryWatcherCallback = (fileName: string) => void;
4494    export interface System {
4495        args: string[];
4496        newLine: string;
4497        useCaseSensitiveFileNames: boolean;
4498        write(s: string): void;
4499        writeOutputIsTTY?(): boolean;
4500        getWidthOfTerminal?(): number;
4501        readFile(path: string, encoding?: string): string | undefined;
4502        getFileSize?(path: string): number;
4503        writeFile(path: string, data: string, writeByteOrderMark?: boolean): void;
4504        /**
4505         * @pollingInterval - this parameter is used in polling-based watchers and ignored in watchers that
4506         * use native OS file watching
4507         */
4508        watchFile?(path: string, callback: FileWatcherCallback, pollingInterval?: number, options?: WatchOptions): FileWatcher;
4509        watchDirectory?(path: string, callback: DirectoryWatcherCallback, recursive?: boolean, options?: WatchOptions): FileWatcher;
4510        resolvePath(path: string): string;
4511        fileExists(path: string): boolean;
4512        directoryExists(path: string): boolean;
4513        createDirectory(path: string): void;
4514        getExecutingFilePath(): string;
4515        getCurrentDirectory(): string;
4516        getDirectories(path: string): string[];
4517        readDirectory(path: string, extensions?: readonly string[], exclude?: readonly string[], include?: readonly string[], depth?: number): string[];
4518        getModifiedTime?(path: string): Date | undefined;
4519        setModifiedTime?(path: string, time: Date): void;
4520        deleteFile?(path: string): void;
4521        /**
4522         * A good implementation is node.js' `crypto.createHash`. (https://nodejs.org/api/crypto.html#crypto_crypto_createhash_algorithm)
4523         */
4524        createHash?(data: string): string;
4525        /** This must be cryptographically secure. Only implement this method using `crypto.createHash("sha256")`. */
4526        createSHA256Hash?(data: string): string;
4527        getMemoryUsage?(): number;
4528        exit(exitCode?: number): void;
4529        realpath?(path: string): string;
4530        setTimeout?(callback: (...args: any[]) => void, ms: number, ...args: any[]): any;
4531        clearTimeout?(timeoutId: any): void;
4532        clearScreen?(): void;
4533        base64decode?(input: string): string;
4534        base64encode?(input: string): string;
4535    }
4536    export interface FileWatcher {
4537        close(): void;
4538    }
4539    export function getNodeMajorVersion(): number | undefined;
4540    export let sys: System;
4541    export {};
4542}
4543declare namespace ts {
4544    type ErrorCallback = (message: DiagnosticMessage, length: number) => void;
4545    interface Scanner {
4546        getStartPos(): number;
4547        getToken(): SyntaxKind;
4548        getTextPos(): number;
4549        getTokenPos(): number;
4550        getTokenText(): string;
4551        getTokenValue(): string;
4552        hasUnicodeEscape(): boolean;
4553        hasExtendedUnicodeEscape(): boolean;
4554        hasPrecedingLineBreak(): boolean;
4555        isIdentifier(): boolean;
4556        isReservedWord(): boolean;
4557        isUnterminated(): boolean;
4558        reScanGreaterToken(): SyntaxKind;
4559        reScanSlashToken(): SyntaxKind;
4560        reScanAsteriskEqualsToken(): SyntaxKind;
4561        reScanTemplateToken(isTaggedTemplate: boolean): SyntaxKind;
4562        reScanTemplateHeadOrNoSubstitutionTemplate(): SyntaxKind;
4563        scanJsxIdentifier(): SyntaxKind;
4564        scanJsxAttributeValue(): SyntaxKind;
4565        reScanJsxAttributeValue(): SyntaxKind;
4566        reScanJsxToken(allowMultilineJsxText?: boolean): JsxTokenSyntaxKind;
4567        reScanLessThanToken(): SyntaxKind;
4568        reScanHashToken(): SyntaxKind;
4569        reScanQuestionToken(): SyntaxKind;
4570        reScanInvalidIdentifier(): SyntaxKind;
4571        scanJsxToken(): JsxTokenSyntaxKind;
4572        scanJsDocToken(): JSDocSyntaxKind;
4573        scan(): SyntaxKind;
4574        getText(): string;
4575        setText(text: string | undefined, start?: number, length?: number): void;
4576        setOnError(onError: ErrorCallback | undefined): void;
4577        setScriptTarget(scriptTarget: ScriptTarget): void;
4578        setLanguageVariant(variant: LanguageVariant): void;
4579        setTextPos(textPos: number): void;
4580        lookAhead<T>(callback: () => T): T;
4581        scanRange<T>(start: number, length: number, callback: () => T): T;
4582        tryScan<T>(callback: () => T): T;
4583        setEtsContext(isEtsContext: boolean): void;
4584    }
4585    function tokenToString(t: SyntaxKind): string | undefined;
4586    function getPositionOfLineAndCharacter(sourceFile: SourceFileLike, line: number, character: number): number;
4587    function getLineAndCharacterOfPosition(sourceFile: SourceFileLike, position: number): LineAndCharacter;
4588    function isWhiteSpaceLike(ch: number): boolean;
4589    /** Does not include line breaks. For that, see isWhiteSpaceLike. */
4590    function isWhiteSpaceSingleLine(ch: number): boolean;
4591    function isLineBreak(ch: number): boolean;
4592    function couldStartTrivia(text: string, pos: number): boolean;
4593    function forEachLeadingCommentRange<U>(text: string, pos: number, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean) => U): U | undefined;
4594    function forEachLeadingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean, state: T) => U, state: T): U | undefined;
4595    function forEachTrailingCommentRange<U>(text: string, pos: number, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean) => U): U | undefined;
4596    function forEachTrailingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean, state: T) => U, state: T): U | undefined;
4597    function reduceEachLeadingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean, state: T, memo: U) => U, state: T, initial: U): U | undefined;
4598    function reduceEachTrailingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean, state: T, memo: U) => U, state: T, initial: U): U | undefined;
4599    function getLeadingCommentRanges(text: string, pos: number): CommentRange[] | undefined;
4600    function getTrailingCommentRanges(text: string, pos: number): CommentRange[] | undefined;
4601    /** Optionally, get the shebang */
4602    function getShebang(text: string): string | undefined;
4603    function isIdentifierStart(ch: number, languageVersion: ScriptTarget | undefined): boolean;
4604    function isIdentifierPart(ch: number, languageVersion: ScriptTarget | undefined, identifierVariant?: LanguageVariant): boolean;
4605    function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean, languageVariant?: LanguageVariant, textInitial?: string, onError?: ErrorCallback, start?: number, length?: number): Scanner;
4606}
4607declare namespace ts {
4608    function isExternalModuleNameRelative(moduleName: string): boolean;
4609    function sortAndDeduplicateDiagnostics<T extends Diagnostic>(diagnostics: readonly T[]): SortedReadonlyArray<T>;
4610    function getDefaultLibFileName(options: CompilerOptions): string;
4611    function textSpanEnd(span: TextSpan): number;
4612    function textSpanIsEmpty(span: TextSpan): boolean;
4613    function textSpanContainsPosition(span: TextSpan, position: number): boolean;
4614    function textSpanContainsTextSpan(span: TextSpan, other: TextSpan): boolean;
4615    function textSpanOverlapsWith(span: TextSpan, other: TextSpan): boolean;
4616    function textSpanOverlap(span1: TextSpan, span2: TextSpan): TextSpan | undefined;
4617    function textSpanIntersectsWithTextSpan(span: TextSpan, other: TextSpan): boolean;
4618    function textSpanIntersectsWith(span: TextSpan, start: number, length: number): boolean;
4619    function decodedTextSpanIntersectsWith(start1: number, length1: number, start2: number, length2: number): boolean;
4620    function textSpanIntersectsWithPosition(span: TextSpan, position: number): boolean;
4621    function textSpanIntersection(span1: TextSpan, span2: TextSpan): TextSpan | undefined;
4622    function createTextSpan(start: number, length: number): TextSpan;
4623    function createTextSpanFromBounds(start: number, end: number): TextSpan;
4624    function textChangeRangeNewSpan(range: TextChangeRange): TextSpan;
4625    function textChangeRangeIsUnchanged(range: TextChangeRange): boolean;
4626    function createTextChangeRange(span: TextSpan, newLength: number): TextChangeRange;
4627    let unchangedTextChangeRange: TextChangeRange;
4628    /**
4629     * Called to merge all the changes that occurred across several versions of a script snapshot
4630     * into a single change.  i.e. if a user keeps making successive edits to a script we will
4631     * have a text change from V1 to V2, V2 to V3, ..., Vn.
4632     *
4633     * This function will then merge those changes into a single change range valid between V1 and
4634     * Vn.
4635     */
4636    function collapseTextChangeRangesAcrossMultipleVersions(changes: readonly TextChangeRange[]): TextChangeRange;
4637    function getTypeParameterOwner(d: Declaration): Declaration | undefined;
4638    type ParameterPropertyDeclaration = ParameterDeclaration & {
4639        parent: ConstructorDeclaration;
4640        name: Identifier;
4641    };
4642    function isParameterPropertyDeclaration(node: Node, parent: Node): node is ParameterPropertyDeclaration;
4643    function isEmptyBindingPattern(node: BindingName): node is BindingPattern;
4644    function isEmptyBindingElement(node: BindingElement): boolean;
4645    function walkUpBindingElementsAndPatterns(binding: BindingElement): VariableDeclaration | ParameterDeclaration;
4646    function getCombinedModifierFlags(node: Declaration): ModifierFlags;
4647    function getCombinedNodeFlags(node: Node): NodeFlags;
4648    /**
4649     * Checks to see if the locale is in the appropriate format,
4650     * and if it is, attempts to set the appropriate language.
4651     */
4652    function validateLocaleAndSetLanguage(locale: string, sys: {
4653        getExecutingFilePath(): string;
4654        resolvePath(path: string): string;
4655        fileExists(fileName: string): boolean;
4656        readFile(fileName: string): string | undefined;
4657    }, errors?: Push<Diagnostic>): void;
4658    function getOriginalNode(node: Node): Node;
4659    function getOriginalNode<T extends Node>(node: Node, nodeTest: (node: Node) => node is T): T;
4660    function getOriginalNode(node: Node | undefined): Node | undefined;
4661    function getOriginalNode<T extends Node>(node: Node | undefined, nodeTest: (node: Node | undefined) => node is T): T | undefined;
4662    /**
4663     * Iterates through the parent chain of a node and performs the callback on each parent until the callback
4664     * returns a truthy value, then returns that value.
4665     * If no such value is found, it applies the callback until the parent pointer is undefined or the callback returns "quit"
4666     * At that point findAncestor returns undefined.
4667     */
4668    function findAncestor<T extends Node>(node: Node | undefined, callback: (element: Node) => element is T): T | undefined;
4669    function findAncestor(node: Node | undefined, callback: (element: Node) => boolean | "quit"): Node | undefined;
4670    /**
4671     * Gets a value indicating whether a node originated in the parse tree.
4672     *
4673     * @param node The node to test.
4674     */
4675    function isParseTreeNode(node: Node): boolean;
4676    /**
4677     * Gets the original parse tree node for a node.
4678     *
4679     * @param node The original node.
4680     * @returns The original parse tree node if found; otherwise, undefined.
4681     */
4682    function getParseTreeNode(node: Node | undefined): Node | undefined;
4683    /**
4684     * Gets the original parse tree node for a node.
4685     *
4686     * @param node The original node.
4687     * @param nodeTest A callback used to ensure the correct type of parse tree node is returned.
4688     * @returns The original parse tree node if found; otherwise, undefined.
4689     */
4690    function getParseTreeNode<T extends Node>(node: T | undefined, nodeTest?: (node: Node) => node is T): T | undefined;
4691    /** Add an extra underscore to identifiers that start with two underscores to avoid issues with magic names like '__proto__' */
4692    function escapeLeadingUnderscores(identifier: string): __String;
4693    /**
4694     * Remove extra underscore from escaped identifier text content.
4695     *
4696     * @param identifier The escaped identifier text.
4697     * @returns The unescaped identifier text.
4698     */
4699    function unescapeLeadingUnderscores(identifier: __String): string;
4700    function idText(identifierOrPrivateName: Identifier | PrivateIdentifier): string;
4701    function symbolName(symbol: Symbol): string;
4702    function getNameOfJSDocTypedef(declaration: JSDocTypedefTag): Identifier | PrivateIdentifier | undefined;
4703    function getNameOfDeclaration(declaration: Declaration | Expression | undefined): DeclarationName | undefined;
4704    function getDecorators(node: HasDecorators): readonly Decorator[] | undefined;
4705    function getModifiers(node: HasModifiers): readonly Modifier[] | undefined;
4706    function getAllDecorators(node: Node | undefined): readonly Decorator[];
4707    function getIllegalDecorators(node: HasIllegalDecorators): readonly Decorator[] | undefined;
4708    /**
4709     * Gets the JSDoc parameter tags for the node if present.
4710     *
4711     * @remarks Returns any JSDoc param tag whose name matches the provided
4712     * parameter, whether a param tag on a containing function
4713     * expression, or a param tag on a variable declaration whose
4714     * initializer is the containing function. The tags closest to the
4715     * node are returned first, so in the previous example, the param
4716     * tag on the containing function expression would be first.
4717     *
4718     * For binding patterns, parameter tags are matched by position.
4719     */
4720    function getJSDocParameterTags(param: ParameterDeclaration): readonly JSDocParameterTag[];
4721    /**
4722     * Gets the JSDoc type parameter tags for the node if present.
4723     *
4724     * @remarks Returns any JSDoc template tag whose names match the provided
4725     * parameter, whether a template tag on a containing function
4726     * expression, or a template tag on a variable declaration whose
4727     * initializer is the containing function. The tags closest to the
4728     * node are returned first, so in the previous example, the template
4729     * tag on the containing function expression would be first.
4730     */
4731    function getJSDocTypeParameterTags(param: TypeParameterDeclaration): readonly JSDocTemplateTag[];
4732    /**
4733     * Return true if the node has JSDoc parameter tags.
4734     *
4735     * @remarks Includes parameter tags that are not directly on the node,
4736     * for example on a variable declaration whose initializer is a function expression.
4737     */
4738    function hasJSDocParameterTags(node: FunctionLikeDeclaration | SignatureDeclaration): boolean;
4739    /** Gets the JSDoc augments tag for the node if present */
4740    function getJSDocAugmentsTag(node: Node): JSDocAugmentsTag | undefined;
4741    /** Gets the JSDoc implements tags for the node if present */
4742    function getJSDocImplementsTags(node: Node): readonly JSDocImplementsTag[];
4743    /** Gets the JSDoc class tag for the node if present */
4744    function getJSDocClassTag(node: Node): JSDocClassTag | undefined;
4745    /** Gets the JSDoc public tag for the node if present */
4746    function getJSDocPublicTag(node: Node): JSDocPublicTag | undefined;
4747    /** Gets the JSDoc private tag for the node if present */
4748    function getJSDocPrivateTag(node: Node): JSDocPrivateTag | undefined;
4749    /** Gets the JSDoc protected tag for the node if present */
4750    function getJSDocProtectedTag(node: Node): JSDocProtectedTag | undefined;
4751    /** Gets the JSDoc protected tag for the node if present */
4752    function getJSDocReadonlyTag(node: Node): JSDocReadonlyTag | undefined;
4753    function getJSDocOverrideTagNoCache(node: Node): JSDocOverrideTag | undefined;
4754    /** Gets the JSDoc deprecated tag for the node if present */
4755    function getJSDocDeprecatedTag(node: Node): JSDocDeprecatedTag | undefined;
4756    /** Gets the JSDoc enum tag for the node if present */
4757    function getJSDocEnumTag(node: Node): JSDocEnumTag | undefined;
4758    /** Gets the JSDoc this tag for the node if present */
4759    function getJSDocThisTag(node: Node): JSDocThisTag | undefined;
4760    /** Gets the JSDoc return tag for the node if present */
4761    function getJSDocReturnTag(node: Node): JSDocReturnTag | undefined;
4762    /** Gets the JSDoc template tag for the node if present */
4763    function getJSDocTemplateTag(node: Node): JSDocTemplateTag | undefined;
4764    /** Gets the JSDoc type tag for the node if present and valid */
4765    function getJSDocTypeTag(node: Node): JSDocTypeTag | undefined;
4766    /**
4767     * Gets the type node for the node if provided via JSDoc.
4768     *
4769     * @remarks The search includes any JSDoc param tag that relates
4770     * to the provided parameter, for example a type tag on the
4771     * parameter itself, or a param tag on a containing function
4772     * expression, or a param tag on a variable declaration whose
4773     * initializer is the containing function. The tags closest to the
4774     * node are examined first, so in the previous example, the type
4775     * tag directly on the node would be returned.
4776     */
4777    function getJSDocType(node: Node): TypeNode | undefined;
4778    /**
4779     * Gets the return type node for the node if provided via JSDoc return tag or type tag.
4780     *
4781     * @remarks `getJSDocReturnTag` just gets the whole JSDoc tag. This function
4782     * gets the type from inside the braces, after the fat arrow, etc.
4783     */
4784    function getJSDocReturnType(node: Node): TypeNode | undefined;
4785    /** Get all JSDoc tags related to a node, including those on parent nodes. */
4786    function getJSDocTags(node: Node): readonly JSDocTag[];
4787    /** Gets all JSDoc tags that match a specified predicate */
4788    function getAllJSDocTags<T extends JSDocTag>(node: Node, predicate: (tag: JSDocTag) => tag is T): readonly T[];
4789    /** Gets all JSDoc tags of a specified kind */
4790    function getAllJSDocTagsOfKind(node: Node, kind: SyntaxKind): readonly JSDocTag[];
4791    /** Gets the text of a jsdoc comment, flattening links to their text. */
4792    function getTextOfJSDocComment(comment?: string | NodeArray<JSDocComment>): string | undefined;
4793    /**
4794     * Gets the effective type parameters. If the node was parsed in a
4795     * JavaScript file, gets the type parameters from the `@template` tag from JSDoc.
4796     *
4797     * This does *not* return type parameters from a jsdoc reference to a generic type, eg
4798     *
4799     * type Id = <T>(x: T) => T
4800     * /** @type {Id} /
4801     * function id(x) { return x }
4802     */
4803    function getEffectiveTypeParameterDeclarations(node: DeclarationWithTypeParameters): readonly TypeParameterDeclaration[];
4804    function getEffectiveConstraintOfTypeParameter(node: TypeParameterDeclaration): TypeNode | undefined;
4805    function isMemberName(node: Node): node is MemberName;
4806    function isPropertyAccessChain(node: Node): node is PropertyAccessChain;
4807    function isElementAccessChain(node: Node): node is ElementAccessChain;
4808    function isCallChain(node: Node): node is CallChain;
4809    function isOptionalChain(node: Node): node is PropertyAccessChain | ElementAccessChain | CallChain | NonNullChain;
4810    function isNullishCoalesce(node: Node): boolean;
4811    function isConstTypeReference(node: Node): boolean;
4812    function skipPartiallyEmittedExpressions(node: Expression): Expression;
4813    function skipPartiallyEmittedExpressions(node: Node): Node;
4814    function isNonNullChain(node: Node): node is NonNullChain;
4815    function isBreakOrContinueStatement(node: Node): node is BreakOrContinueStatement;
4816    function isNamedExportBindings(node: Node): node is NamedExportBindings;
4817    function isUnparsedTextLike(node: Node): node is UnparsedTextLike;
4818    function isUnparsedNode(node: Node): node is UnparsedNode;
4819    function isJSDocPropertyLikeTag(node: Node): node is JSDocPropertyLikeTag;
4820    /**
4821     * True if kind is of some token syntax kind.
4822     * For example, this is true for an IfKeyword but not for an IfStatement.
4823     * Literals are considered tokens, except TemplateLiteral, but does include TemplateHead/Middle/Tail.
4824     */
4825    function isTokenKind(kind: SyntaxKind): boolean;
4826    /**
4827     * True if node is of some token syntax kind.
4828     * For example, this is true for an IfKeyword but not for an IfStatement.
4829     * Literals are considered tokens, except TemplateLiteral, but does include TemplateHead/Middle/Tail.
4830     */
4831    function isToken(n: Node): boolean;
4832    function isLiteralExpression(node: Node): node is LiteralExpression;
4833    function isTemplateLiteralToken(node: Node): node is TemplateLiteralToken;
4834    function isTemplateMiddleOrTemplateTail(node: Node): node is TemplateMiddle | TemplateTail;
4835    function isImportOrExportSpecifier(node: Node): node is ImportSpecifier | ExportSpecifier;
4836    function isTypeOnlyImportOrExportDeclaration(node: Node): node is TypeOnlyAliasDeclaration;
4837    function isAssertionKey(node: Node): node is AssertionKey;
4838    function isStringTextContainingNode(node: Node): node is StringLiteral | TemplateLiteralToken;
4839    function isModifier(node: Node): node is Modifier;
4840    function isEntityName(node: Node): node is EntityName;
4841    function isPropertyName(node: Node): node is PropertyName;
4842    function isBindingName(node: Node): node is BindingName;
4843    function isFunctionLike(node: Node | undefined): node is SignatureDeclaration;
4844    function isClassElement(node: Node): node is ClassElement;
4845    function isClassLike(node: Node): node is ClassLikeDeclaration;
4846    function isStruct(node: Node): node is StructDeclaration;
4847    function isAccessor(node: Node): node is AccessorDeclaration;
4848    function isAutoAccessorPropertyDeclaration(node: Node): node is AutoAccessorPropertyDeclaration;
4849    function isModifierLike(node: Node): node is ModifierLike;
4850    function isTypeElement(node: Node): node is TypeElement;
4851    function isClassOrTypeElement(node: Node): node is ClassElement | TypeElement;
4852    function isObjectLiteralElementLike(node: Node): node is ObjectLiteralElementLike;
4853    /**
4854     * Node test that determines whether a node is a valid type node.
4855     * This differs from the `isPartOfTypeNode` function which determines whether a node is *part*
4856     * of a TypeNode.
4857     */
4858    function isTypeNode(node: Node): node is TypeNode;
4859    function isFunctionOrConstructorTypeNode(node: Node): node is FunctionTypeNode | ConstructorTypeNode;
4860    function isPropertyAccessOrQualifiedName(node: Node): node is PropertyAccessExpression | QualifiedName;
4861    function isCallLikeExpression(node: Node): node is CallLikeExpression;
4862    function isCallOrNewExpression(node: Node): node is CallExpression | NewExpression;
4863    function isTemplateLiteral(node: Node): node is TemplateLiteral;
4864    function isAssertionExpression(node: Node): node is AssertionExpression;
4865    function isIterationStatement(node: Node, lookInLabeledStatements: false): node is IterationStatement;
4866    function isIterationStatement(node: Node, lookInLabeledStatements: boolean): node is IterationStatement | LabeledStatement;
4867    function isJsxOpeningLikeElement(node: Node): node is JsxOpeningLikeElement;
4868    function isCaseOrDefaultClause(node: Node): node is CaseOrDefaultClause;
4869    /** True if node is of a kind that may contain comment text. */
4870    function isJSDocCommentContainingNode(node: Node): boolean;
4871    function isSetAccessor(node: Node): node is SetAccessorDeclaration;
4872    function isGetAccessor(node: Node): node is GetAccessorDeclaration;
4873    /** True if has initializer node attached to it. */
4874    function hasOnlyExpressionInitializer(node: Node): node is HasExpressionInitializer;
4875    function isObjectLiteralElement(node: Node): node is ObjectLiteralElement;
4876    function isStringLiteralLike(node: Node): node is StringLiteralLike;
4877    function isJSDocLinkLike(node: Node): node is JSDocLink | JSDocLinkCode | JSDocLinkPlain;
4878    function hasRestParameter(s: SignatureDeclaration | JSDocSignature): boolean;
4879    function isRestParameter(node: ParameterDeclaration | JSDocParameterTag): boolean;
4880}
4881declare namespace ts {
4882    function getLeadingCommentRangesOfNode(node: Node, sourceFileOfNode: SourceFile): CommentRange[] | undefined;
4883    function createTextWriter(newLine: string): EmitTextWriter;
4884    /**
4885     * Bypasses immutability and directly sets the `parent` property of each `Node` recursively.
4886     * @param rootNode The root node from which to start the recursion.
4887     * @param incremental When `true`, only recursively descends through nodes whose `parent` pointers are incorrect.
4888     * This allows us to quickly bail out of setting `parent` for subtrees during incremental parsing.
4889     */
4890    function setParentRecursive<T extends Node>(rootNode: T, incremental: boolean): T;
4891    function setParentRecursive<T extends Node>(rootNode: T | undefined, incremental: boolean): T | undefined;
4892}
4893declare namespace ts {
4894    const factory: NodeFactory;
4895    function createUnparsedSourceFile(text: string): UnparsedSource;
4896    function createUnparsedSourceFile(inputFile: InputFiles, type: "js" | "dts", stripInternal?: boolean): UnparsedSource;
4897    function createUnparsedSourceFile(text: string, mapPath: string | undefined, map: string | undefined): UnparsedSource;
4898    function createInputFiles(javascriptText: string, declarationText: string): InputFiles;
4899    function createInputFiles(readFileText: (path: string) => string | undefined, javascriptPath: string, javascriptMapPath: string | undefined, declarationPath: string, declarationMapPath: string | undefined, buildInfoPath: string | undefined): InputFiles;
4900    function createInputFiles(javascriptText: string, declarationText: string, javascriptMapPath: string | undefined, javascriptMapText: string | undefined, declarationMapPath: string | undefined, declarationMapText: string | undefined): InputFiles;
4901    /**
4902     * Create an external source map source file reference
4903     */
4904    function createSourceMapSource(fileName: string, text: string, skipTrivia?: (pos: number) => number): SourceMapSource;
4905    function setOriginalNode<T extends Node>(node: T, original: Node | undefined): T;
4906}
4907declare namespace ts {
4908    /**
4909     * Clears any `EmitNode` entries from parse-tree nodes.
4910     * @param sourceFile A source file.
4911     */
4912    function disposeEmitNodes(sourceFile: SourceFile | undefined): void;
4913    /**
4914     * Sets flags that control emit behavior of a node.
4915     */
4916    function setEmitFlags<T extends Node>(node: T, emitFlags: EmitFlags): T;
4917    /**
4918     * Gets a custom text range to use when emitting source maps.
4919     */
4920    function getSourceMapRange(node: Node): SourceMapRange;
4921    /**
4922     * Sets a custom text range to use when emitting source maps.
4923     */
4924    function setSourceMapRange<T extends Node>(node: T, range: SourceMapRange | undefined): T;
4925    /**
4926     * Gets the TextRange to use for source maps for a token of a node.
4927     */
4928    function getTokenSourceMapRange(node: Node, token: SyntaxKind): SourceMapRange | undefined;
4929    /**
4930     * Sets the TextRange to use for source maps for a token of a node.
4931     */
4932    function setTokenSourceMapRange<T extends Node>(node: T, token: SyntaxKind, range: SourceMapRange | undefined): T;
4933    /**
4934     * Gets a custom text range to use when emitting comments.
4935     */
4936    function getCommentRange(node: Node): TextRange;
4937    /**
4938     * Sets a custom text range to use when emitting comments.
4939     */
4940    function setCommentRange<T extends Node>(node: T, range: TextRange): T;
4941    function getSyntheticLeadingComments(node: Node): SynthesizedComment[] | undefined;
4942    function setSyntheticLeadingComments<T extends Node>(node: T, comments: SynthesizedComment[] | undefined): T;
4943    function addSyntheticLeadingComment<T extends Node>(node: T, kind: SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia, text: string, hasTrailingNewLine?: boolean): T;
4944    function getSyntheticTrailingComments(node: Node): SynthesizedComment[] | undefined;
4945    function setSyntheticTrailingComments<T extends Node>(node: T, comments: SynthesizedComment[] | undefined): T;
4946    function addSyntheticTrailingComment<T extends Node>(node: T, kind: SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia, text: string, hasTrailingNewLine?: boolean): T;
4947    function moveSyntheticComments<T extends Node>(node: T, original: Node): T;
4948    /**
4949     * Gets the constant value to emit for an expression representing an enum.
4950     */
4951    function getConstantValue(node: AccessExpression): string | number | undefined;
4952    /**
4953     * Sets the constant value to emit for an expression.
4954     */
4955    function setConstantValue(node: AccessExpression, value: string | number): AccessExpression;
4956    /**
4957     * Adds an EmitHelper to a node.
4958     */
4959    function addEmitHelper<T extends Node>(node: T, helper: EmitHelper): T;
4960    /**
4961     * Add EmitHelpers to a node.
4962     */
4963    function addEmitHelpers<T extends Node>(node: T, helpers: EmitHelper[] | undefined): T;
4964    /**
4965     * Removes an EmitHelper from a node.
4966     */
4967    function removeEmitHelper(node: Node, helper: EmitHelper): boolean;
4968    /**
4969     * Gets the EmitHelpers of a node.
4970     */
4971    function getEmitHelpers(node: Node): EmitHelper[] | undefined;
4972    /**
4973     * Moves matching emit helpers from a source node to a target node.
4974     */
4975    function moveEmitHelpers(source: Node, target: Node, predicate: (helper: EmitHelper) => boolean): void;
4976}
4977declare namespace ts {
4978    function isNumericLiteral(node: Node): node is NumericLiteral;
4979    function isBigIntLiteral(node: Node): node is BigIntLiteral;
4980    function isStringLiteral(node: Node): node is StringLiteral;
4981    function isJsxText(node: Node): node is JsxText;
4982    function isRegularExpressionLiteral(node: Node): node is RegularExpressionLiteral;
4983    function isNoSubstitutionTemplateLiteral(node: Node): node is NoSubstitutionTemplateLiteral;
4984    function isTemplateHead(node: Node): node is TemplateHead;
4985    function isTemplateMiddle(node: Node): node is TemplateMiddle;
4986    function isTemplateTail(node: Node): node is TemplateTail;
4987    function isDotDotDotToken(node: Node): node is DotDotDotToken;
4988    function isPlusToken(node: Node): node is PlusToken;
4989    function isMinusToken(node: Node): node is MinusToken;
4990    function isAsteriskToken(node: Node): node is AsteriskToken;
4991    function isIdentifier(node: Node): node is Identifier;
4992    function isPrivateIdentifier(node: Node): node is PrivateIdentifier;
4993    function isQualifiedName(node: Node): node is QualifiedName;
4994    function isComputedPropertyName(node: Node): node is ComputedPropertyName;
4995    function isTypeParameterDeclaration(node: Node): node is TypeParameterDeclaration;
4996    function isParameter(node: Node): node is ParameterDeclaration;
4997    function isDecorator(node: Node): node is Decorator;
4998    function isPropertySignature(node: Node): node is PropertySignature;
4999    function isPropertyDeclaration(node: Node): node is PropertyDeclaration;
5000    function isMethodSignature(node: Node): node is MethodSignature;
5001    function isMethodDeclaration(node: Node): node is MethodDeclaration;
5002    function isClassStaticBlockDeclaration(node: Node): node is ClassStaticBlockDeclaration;
5003    function isConstructorDeclaration(node: Node): node is ConstructorDeclaration;
5004    function isGetAccessorDeclaration(node: Node): node is GetAccessorDeclaration;
5005    function isSetAccessorDeclaration(node: Node): node is SetAccessorDeclaration;
5006    function isCallSignatureDeclaration(node: Node): node is CallSignatureDeclaration;
5007    function isConstructSignatureDeclaration(node: Node): node is ConstructSignatureDeclaration;
5008    function isIndexSignatureDeclaration(node: Node): node is IndexSignatureDeclaration;
5009    function isTypePredicateNode(node: Node): node is TypePredicateNode;
5010    function isTypeReferenceNode(node: Node): node is TypeReferenceNode;
5011    function isFunctionTypeNode(node: Node): node is FunctionTypeNode;
5012    function isConstructorTypeNode(node: Node): node is ConstructorTypeNode;
5013    function isTypeQueryNode(node: Node): node is TypeQueryNode;
5014    function isTypeLiteralNode(node: Node): node is TypeLiteralNode;
5015    function isArrayTypeNode(node: Node): node is ArrayTypeNode;
5016    function isTupleTypeNode(node: Node): node is TupleTypeNode;
5017    function isNamedTupleMember(node: Node): node is NamedTupleMember;
5018    function isOptionalTypeNode(node: Node): node is OptionalTypeNode;
5019    function isRestTypeNode(node: Node): node is RestTypeNode;
5020    function isUnionTypeNode(node: Node): node is UnionTypeNode;
5021    function isIntersectionTypeNode(node: Node): node is IntersectionTypeNode;
5022    function isConditionalTypeNode(node: Node): node is ConditionalTypeNode;
5023    function isInferTypeNode(node: Node): node is InferTypeNode;
5024    function isParenthesizedTypeNode(node: Node): node is ParenthesizedTypeNode;
5025    function isThisTypeNode(node: Node): node is ThisTypeNode;
5026    function isTypeOperatorNode(node: Node): node is TypeOperatorNode;
5027    function isIndexedAccessTypeNode(node: Node): node is IndexedAccessTypeNode;
5028    function isMappedTypeNode(node: Node): node is MappedTypeNode;
5029    function isLiteralTypeNode(node: Node): node is LiteralTypeNode;
5030    function isImportTypeNode(node: Node): node is ImportTypeNode;
5031    function isTemplateLiteralTypeSpan(node: Node): node is TemplateLiteralTypeSpan;
5032    function isTemplateLiteralTypeNode(node: Node): node is TemplateLiteralTypeNode;
5033    function isObjectBindingPattern(node: Node): node is ObjectBindingPattern;
5034    function isArrayBindingPattern(node: Node): node is ArrayBindingPattern;
5035    function isBindingElement(node: Node): node is BindingElement;
5036    function isArrayLiteralExpression(node: Node): node is ArrayLiteralExpression;
5037    function isObjectLiteralExpression(node: Node): node is ObjectLiteralExpression;
5038    function isPropertyAccessExpression(node: Node): node is PropertyAccessExpression;
5039    function isElementAccessExpression(node: Node): node is ElementAccessExpression;
5040    function isCallExpression(node: Node): node is CallExpression;
5041    function isNewExpression(node: Node): node is NewExpression;
5042    function isTaggedTemplateExpression(node: Node): node is TaggedTemplateExpression;
5043    function isTypeAssertionExpression(node: Node): node is TypeAssertion;
5044    function isParenthesizedExpression(node: Node): node is ParenthesizedExpression;
5045    function isFunctionExpression(node: Node): node is FunctionExpression;
5046    function isEtsComponentExpression(node: Node): node is EtsComponentExpression;
5047    function isArrowFunction(node: Node): node is ArrowFunction;
5048    function isDeleteExpression(node: Node): node is DeleteExpression;
5049    function isTypeOfExpression(node: Node): node is TypeOfExpression;
5050    function isVoidExpression(node: Node): node is VoidExpression;
5051    function isAwaitExpression(node: Node): node is AwaitExpression;
5052    function isPrefixUnaryExpression(node: Node): node is PrefixUnaryExpression;
5053    function isPostfixUnaryExpression(node: Node): node is PostfixUnaryExpression;
5054    function isBinaryExpression(node: Node): node is BinaryExpression;
5055    function isConditionalExpression(node: Node): node is ConditionalExpression;
5056    function isTemplateExpression(node: Node): node is TemplateExpression;
5057    function isYieldExpression(node: Node): node is YieldExpression;
5058    function isSpreadElement(node: Node): node is SpreadElement;
5059    function isClassExpression(node: Node): node is ClassExpression;
5060    function isOmittedExpression(node: Node): node is OmittedExpression;
5061    function isExpressionWithTypeArguments(node: Node): node is ExpressionWithTypeArguments;
5062    function isAsExpression(node: Node): node is AsExpression;
5063    function isSatisfiesExpression(node: Node): node is SatisfiesExpression;
5064    function isNonNullExpression(node: Node): node is NonNullExpression;
5065    function isMetaProperty(node: Node): node is MetaProperty;
5066    function isSyntheticExpression(node: Node): node is SyntheticExpression;
5067    function isPartiallyEmittedExpression(node: Node): node is PartiallyEmittedExpression;
5068    function isCommaListExpression(node: Node): node is CommaListExpression;
5069    function isTemplateSpan(node: Node): node is TemplateSpan;
5070    function isSemicolonClassElement(node: Node): node is SemicolonClassElement;
5071    function isBlock(node: Node): node is Block;
5072    function isVariableStatement(node: Node): node is VariableStatement;
5073    function isEmptyStatement(node: Node): node is EmptyStatement;
5074    function isExpressionStatement(node: Node): node is ExpressionStatement;
5075    function isIfStatement(node: Node): node is IfStatement;
5076    function isDoStatement(node: Node): node is DoStatement;
5077    function isWhileStatement(node: Node): node is WhileStatement;
5078    function isForStatement(node: Node): node is ForStatement;
5079    function isForInStatement(node: Node): node is ForInStatement;
5080    function isForOfStatement(node: Node): node is ForOfStatement;
5081    function isContinueStatement(node: Node): node is ContinueStatement;
5082    function isBreakStatement(node: Node): node is BreakStatement;
5083    function isReturnStatement(node: Node): node is ReturnStatement;
5084    function isWithStatement(node: Node): node is WithStatement;
5085    function isSwitchStatement(node: Node): node is SwitchStatement;
5086    function isLabeledStatement(node: Node): node is LabeledStatement;
5087    function isThrowStatement(node: Node): node is ThrowStatement;
5088    function isTryStatement(node: Node): node is TryStatement;
5089    function isDebuggerStatement(node: Node): node is DebuggerStatement;
5090    function isVariableDeclaration(node: Node): node is VariableDeclaration;
5091    function isVariableDeclarationList(node: Node): node is VariableDeclarationList;
5092    function isFunctionDeclaration(node: Node): node is FunctionDeclaration;
5093    function isClassDeclaration(node: Node): node is ClassDeclaration;
5094    function isStructDeclaration(node: Node): node is StructDeclaration;
5095    function isInterfaceDeclaration(node: Node): node is InterfaceDeclaration;
5096    function isTypeAliasDeclaration(node: Node): node is TypeAliasDeclaration;
5097    function isEnumDeclaration(node: Node): node is EnumDeclaration;
5098    function isModuleDeclaration(node: Node): node is ModuleDeclaration;
5099    function isModuleBlock(node: Node): node is ModuleBlock;
5100    function isCaseBlock(node: Node): node is CaseBlock;
5101    function isNamespaceExportDeclaration(node: Node): node is NamespaceExportDeclaration;
5102    function isImportEqualsDeclaration(node: Node): node is ImportEqualsDeclaration;
5103    function isImportDeclaration(node: Node): node is ImportDeclaration;
5104    function isImportClause(node: Node): node is ImportClause;
5105    function isImportTypeAssertionContainer(node: Node): node is ImportTypeAssertionContainer;
5106    function isAssertClause(node: Node): node is AssertClause;
5107    function isAssertEntry(node: Node): node is AssertEntry;
5108    function isNamespaceImport(node: Node): node is NamespaceImport;
5109    function isNamespaceExport(node: Node): node is NamespaceExport;
5110    function isNamedImports(node: Node): node is NamedImports;
5111    function isImportSpecifier(node: Node): node is ImportSpecifier;
5112    function isExportAssignment(node: Node): node is ExportAssignment;
5113    function isExportDeclaration(node: Node): node is ExportDeclaration;
5114    function isNamedExports(node: Node): node is NamedExports;
5115    function isExportSpecifier(node: Node): node is ExportSpecifier;
5116    function isMissingDeclaration(node: Node): node is MissingDeclaration;
5117    function isNotEmittedStatement(node: Node): node is NotEmittedStatement;
5118    function isExternalModuleReference(node: Node): node is ExternalModuleReference;
5119    function isJsxElement(node: Node): node is JsxElement;
5120    function isJsxSelfClosingElement(node: Node): node is JsxSelfClosingElement;
5121    function isJsxOpeningElement(node: Node): node is JsxOpeningElement;
5122    function isJsxClosingElement(node: Node): node is JsxClosingElement;
5123    function isJsxFragment(node: Node): node is JsxFragment;
5124    function isJsxOpeningFragment(node: Node): node is JsxOpeningFragment;
5125    function isJsxClosingFragment(node: Node): node is JsxClosingFragment;
5126    function isJsxAttribute(node: Node): node is JsxAttribute;
5127    function isJsxAttributes(node: Node): node is JsxAttributes;
5128    function isJsxSpreadAttribute(node: Node): node is JsxSpreadAttribute;
5129    function isJsxExpression(node: Node): node is JsxExpression;
5130    function isCaseClause(node: Node): node is CaseClause;
5131    function isDefaultClause(node: Node): node is DefaultClause;
5132    function isHeritageClause(node: Node): node is HeritageClause;
5133    function isCatchClause(node: Node): node is CatchClause;
5134    function isPropertyAssignment(node: Node): node is PropertyAssignment;
5135    function isShorthandPropertyAssignment(node: Node): node is ShorthandPropertyAssignment;
5136    function isSpreadAssignment(node: Node): node is SpreadAssignment;
5137    function isEnumMember(node: Node): node is EnumMember;
5138    function isUnparsedPrepend(node: Node): node is UnparsedPrepend;
5139    function isSourceFile(node: Node): node is SourceFile;
5140    function isBundle(node: Node): node is Bundle;
5141    function isUnparsedSource(node: Node): node is UnparsedSource;
5142    function isJSDocTypeExpression(node: Node): node is JSDocTypeExpression;
5143    function isJSDocNameReference(node: Node): node is JSDocNameReference;
5144    function isJSDocMemberName(node: Node): node is JSDocMemberName;
5145    function isJSDocLink(node: Node): node is JSDocLink;
5146    function isJSDocLinkCode(node: Node): node is JSDocLinkCode;
5147    function isJSDocLinkPlain(node: Node): node is JSDocLinkPlain;
5148    function isJSDocAllType(node: Node): node is JSDocAllType;
5149    function isJSDocUnknownType(node: Node): node is JSDocUnknownType;
5150    function isJSDocNullableType(node: Node): node is JSDocNullableType;
5151    function isJSDocNonNullableType(node: Node): node is JSDocNonNullableType;
5152    function isJSDocOptionalType(node: Node): node is JSDocOptionalType;
5153    function isJSDocFunctionType(node: Node): node is JSDocFunctionType;
5154    function isJSDocVariadicType(node: Node): node is JSDocVariadicType;
5155    function isJSDocNamepathType(node: Node): node is JSDocNamepathType;
5156    function isJSDoc(node: Node): node is JSDoc;
5157    function isJSDocTypeLiteral(node: Node): node is JSDocTypeLiteral;
5158    function isJSDocSignature(node: Node): node is JSDocSignature;
5159    function isJSDocAugmentsTag(node: Node): node is JSDocAugmentsTag;
5160    function isJSDocAuthorTag(node: Node): node is JSDocAuthorTag;
5161    function isJSDocClassTag(node: Node): node is JSDocClassTag;
5162    function isJSDocCallbackTag(node: Node): node is JSDocCallbackTag;
5163    function isJSDocPublicTag(node: Node): node is JSDocPublicTag;
5164    function isJSDocPrivateTag(node: Node): node is JSDocPrivateTag;
5165    function isJSDocProtectedTag(node: Node): node is JSDocProtectedTag;
5166    function isJSDocReadonlyTag(node: Node): node is JSDocReadonlyTag;
5167    function isJSDocOverrideTag(node: Node): node is JSDocOverrideTag;
5168    function isJSDocDeprecatedTag(node: Node): node is JSDocDeprecatedTag;
5169    function isJSDocSeeTag(node: Node): node is JSDocSeeTag;
5170    function isJSDocEnumTag(node: Node): node is JSDocEnumTag;
5171    function isJSDocParameterTag(node: Node): node is JSDocParameterTag;
5172    function isJSDocReturnTag(node: Node): node is JSDocReturnTag;
5173    function isJSDocThisTag(node: Node): node is JSDocThisTag;
5174    function isJSDocTypeTag(node: Node): node is JSDocTypeTag;
5175    function isJSDocTemplateTag(node: Node): node is JSDocTemplateTag;
5176    function isJSDocTypedefTag(node: Node): node is JSDocTypedefTag;
5177    function isJSDocUnknownTag(node: Node): node is JSDocUnknownTag;
5178    function isJSDocPropertyTag(node: Node): node is JSDocPropertyTag;
5179    function isJSDocImplementsTag(node: Node): node is JSDocImplementsTag;
5180}
5181declare namespace ts {
5182    function setTextRange<T extends TextRange>(range: T, location: TextRange | undefined): T;
5183    function canHaveModifiers(node: Node): node is HasModifiers;
5184    function canHaveDecorators(node: Node): node is HasDecorators;
5185}
5186declare namespace ts {
5187    /**
5188     * Invokes a callback for each child of the given node. The 'cbNode' callback is invoked for all child nodes
5189     * stored in properties. If a 'cbNodes' callback is specified, it is invoked for embedded arrays; otherwise,
5190     * embedded arrays are flattened and the 'cbNode' callback is invoked for each element. If a callback returns
5191     * a truthy value, iteration stops and that value is returned. Otherwise, undefined is returned.
5192     *
5193     * @param node a given node to visit its children
5194     * @param cbNode a callback to be invoked for all child nodes
5195     * @param cbNodes a callback to be invoked for embedded array
5196     *
5197     * @remarks `forEachChild` must visit the children of a node in the order
5198     * that they appear in the source code. The language service depends on this property to locate nodes by position.
5199     */
5200    export function forEachChild<T>(node: Node, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined;
5201    export interface CreateSourceFileOptions {
5202        languageVersion: ScriptTarget;
5203        /**
5204         * Controls the format the file is detected as - this can be derived from only the path
5205         * and files on disk, but needs to be done with a module resolution cache in scope to be performant.
5206         * This is usually `undefined` for compilations that do not have `moduleResolution` values of `node16` or `nodenext`.
5207         */
5208        impliedNodeFormat?: ModuleKind.ESNext | ModuleKind.CommonJS;
5209        /**
5210         * Controls how module-y-ness is set for the given file. Usually the result of calling
5211         * `getSetExternalModuleIndicator` on a valid `CompilerOptions` object. If not present, the default
5212         * check specified by `isFileProbablyExternalModule` will be used to set the field.
5213         */
5214        setExternalModuleIndicator?: (file: SourceFile) => void;
5215    }
5216    export function createSourceFile(fileName: string, sourceText: string, languageVersionOrOptions: ScriptTarget | CreateSourceFileOptions, setParentNodes?: boolean, scriptKind?: ScriptKind, options?: CompilerOptions): SourceFile;
5217    export function parseIsolatedEntityName(text: string, languageVersion: ScriptTarget): EntityName | undefined;
5218    /**
5219     * Parse json text into SyntaxTree and return node and parse errors if any
5220     * @param fileName
5221     * @param sourceText
5222     */
5223    export function parseJsonText(fileName: string, sourceText: string): JsonSourceFile;
5224    export function isExternalModule(file: SourceFile): boolean;
5225    export function updateSourceFile(sourceFile: SourceFile, newText: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean, option?: CompilerOptions): SourceFile;
5226    export {};
5227}
5228declare namespace ts {
5229    export function parseCommandLine(commandLine: readonly string[], readFile?: (path: string) => string | undefined): ParsedCommandLine;
5230    export type DiagnosticReporter = (diagnostic: Diagnostic) => void;
5231    /**
5232     * Reports config file diagnostics
5233     */
5234    export interface ConfigFileDiagnosticsReporter {
5235        /**
5236         * Reports unrecoverable error when parsing config file
5237         */
5238        onUnRecoverableConfigFileDiagnostic: DiagnosticReporter;
5239    }
5240    /**
5241     * Interface extending ParseConfigHost to support ParseConfigFile that reads config file and reports errors
5242     */
5243    export interface ParseConfigFileHost extends ParseConfigHost, ConfigFileDiagnosticsReporter {
5244        getCurrentDirectory(): string;
5245    }
5246    /**
5247     * Reads the config file, reports errors if any and exits if the config file cannot be found
5248     */
5249    export function getParsedCommandLineOfConfigFile(configFileName: string, optionsToExtend: CompilerOptions | undefined, host: ParseConfigFileHost, extendedConfigCache?: Map<ExtendedConfigCacheEntry>, watchOptionsToExtend?: WatchOptions, extraFileExtensions?: readonly FileExtensionInfo[]): ParsedCommandLine | undefined;
5250    /**
5251     * Read tsconfig.json file
5252     * @param fileName The path to the config file
5253     */
5254    export function readConfigFile(fileName: string, readFile: (path: string) => string | undefined): {
5255        config?: any;
5256        error?: Diagnostic;
5257    };
5258    /**
5259     * Parse the text of the tsconfig.json file
5260     * @param fileName The path to the config file
5261     * @param jsonText The text of the config file
5262     */
5263    export function parseConfigFileTextToJson(fileName: string, jsonText: string): {
5264        config?: any;
5265        error?: Diagnostic;
5266    };
5267    /**
5268     * Read tsconfig.json file
5269     * @param fileName The path to the config file
5270     */
5271    export function readJsonConfigFile(fileName: string, readFile: (path: string) => string | undefined): TsConfigSourceFile;
5272    /**
5273     * Convert the json syntax tree into the json value
5274     */
5275    export function convertToObject(sourceFile: JsonSourceFile, errors: Push<Diagnostic>): any;
5276    /**
5277     * Parse the contents of a config file (tsconfig.json).
5278     * @param json The contents of the config file to parse
5279     * @param host Instance of ParseConfigHost used to enumerate files in folder.
5280     * @param basePath A root directory to resolve relative path entries in the config
5281     *    file to. e.g. outDir
5282     */
5283    export function parseJsonConfigFileContent(json: any, host: ParseConfigHost, basePath: string, existingOptions?: CompilerOptions, configFileName?: string, resolutionStack?: Path[], extraFileExtensions?: readonly FileExtensionInfo[], extendedConfigCache?: Map<ExtendedConfigCacheEntry>, existingWatchOptions?: WatchOptions): ParsedCommandLine;
5284    /**
5285     * Parse the contents of a config file (tsconfig.json).
5286     * @param jsonNode The contents of the config file to parse
5287     * @param host Instance of ParseConfigHost used to enumerate files in folder.
5288     * @param basePath A root directory to resolve relative path entries in the config
5289     *    file to. e.g. outDir
5290     */
5291    export function parseJsonSourceFileConfigFileContent(sourceFile: TsConfigSourceFile, host: ParseConfigHost, basePath: string, existingOptions?: CompilerOptions, configFileName?: string, resolutionStack?: Path[], extraFileExtensions?: readonly FileExtensionInfo[], extendedConfigCache?: Map<ExtendedConfigCacheEntry>, existingWatchOptions?: WatchOptions): ParsedCommandLine;
5292    export interface ParsedTsconfig {
5293        raw: any;
5294        options?: CompilerOptions;
5295        watchOptions?: WatchOptions;
5296        typeAcquisition?: TypeAcquisition;
5297        /**
5298         * Note that the case of the config path has not yet been normalized, as no files have been imported into the project yet
5299         */
5300        extendedConfigPath?: string;
5301    }
5302    export interface ExtendedConfigCacheEntry {
5303        extendedResult: TsConfigSourceFile;
5304        extendedConfig: ParsedTsconfig | undefined;
5305    }
5306    export function convertCompilerOptionsFromJson(jsonOptions: any, basePath: string, configFileName?: string): {
5307        options: CompilerOptions;
5308        errors: Diagnostic[];
5309    };
5310    export function convertTypeAcquisitionFromJson(jsonOptions: any, basePath: string, configFileName?: string): {
5311        options: TypeAcquisition;
5312        errors: Diagnostic[];
5313    };
5314    export {};
5315}
5316declare namespace ts {
5317    export function getEffectiveTypeRoots(options: CompilerOptions, host: GetEffectiveTypeRootsHost): string[] | undefined;
5318    /**
5319     * @param {string | undefined} containingFile - file that contains type reference directive, can be undefined if containing file is unknown.
5320     * This is possible in case if resolution is performed for directives specified via 'types' parameter. In this case initial path for secondary lookups
5321     * is assumed to be the same as root directory of the project.
5322     */
5323    export function resolveTypeReferenceDirective(typeReferenceDirectiveName: string, containingFile: string | undefined, options: CompilerOptions, host: ModuleResolutionHost, redirectedReference?: ResolvedProjectReference, cache?: TypeReferenceDirectiveResolutionCache, resolutionMode?: SourceFile["impliedNodeFormat"]): ResolvedTypeReferenceDirectiveWithFailedLookupLocations;
5324    /**
5325     * Given a set of options, returns the set of type directive names
5326     *   that should be included for this program automatically.
5327     * This list could either come from the config file,
5328     *   or from enumerating the types root + initial secondary types lookup location.
5329     * More type directives might appear in the program later as a result of loading actual source files;
5330     *   this list is only the set of defaults that are implicitly included.
5331     */
5332    export function getAutomaticTypeDirectiveNames(options: CompilerOptions, host: ModuleResolutionHost): string[];
5333    export interface TypeReferenceDirectiveResolutionCache extends PerDirectoryResolutionCache<ResolvedTypeReferenceDirectiveWithFailedLookupLocations>, PackageJsonInfoCache {
5334    }
5335    export interface ModeAwareCache<T> {
5336        get(key: string, mode: ModuleKind.CommonJS | ModuleKind.ESNext | undefined): T | undefined;
5337        set(key: string, mode: ModuleKind.CommonJS | ModuleKind.ESNext | undefined, value: T): this;
5338        delete(key: string, mode: ModuleKind.CommonJS | ModuleKind.ESNext | undefined): this;
5339        has(key: string, mode: ModuleKind.CommonJS | ModuleKind.ESNext | undefined): boolean;
5340        forEach(cb: (elem: T, key: string, mode: ModuleKind.CommonJS | ModuleKind.ESNext | undefined) => void): void;
5341        size(): number;
5342    }
5343    /**
5344     * Cached resolutions per containing directory.
5345     * This assumes that any module id will have the same resolution for sibling files located in the same folder.
5346     */
5347    export interface PerDirectoryResolutionCache<T> {
5348        getOrCreateCacheForDirectory(directoryName: string, redirectedReference?: ResolvedProjectReference): ModeAwareCache<T>;
5349        clear(): void;
5350        /**
5351         *  Updates with the current compilerOptions the cache will operate with.
5352         *  This updates the redirects map as well if needed so module resolutions are cached if they can across the projects
5353         */
5354        update(options: CompilerOptions): void;
5355    }
5356    export interface ModuleResolutionCache extends PerDirectoryResolutionCache<ResolvedModuleWithFailedLookupLocations>, NonRelativeModuleNameResolutionCache, PackageJsonInfoCache {
5357        getPackageJsonInfoCache(): PackageJsonInfoCache;
5358    }
5359    /**
5360     * Stored map from non-relative module name to a table: directory -> result of module lookup in this directory
5361     * We support only non-relative module names because resolution of relative module names is usually more deterministic and thus less expensive.
5362     */
5363    export interface NonRelativeModuleNameResolutionCache extends PackageJsonInfoCache {
5364        getOrCreateCacheForModuleName(nonRelativeModuleName: string, mode: ModuleKind.CommonJS | ModuleKind.ESNext | undefined, redirectedReference?: ResolvedProjectReference): PerModuleNameCache;
5365    }
5366    export interface PackageJsonInfoCache {
5367        clear(): void;
5368    }
5369    export interface PerModuleNameCache {
5370        get(directory: string): ResolvedModuleWithFailedLookupLocations | undefined;
5371        set(directory: string, result: ResolvedModuleWithFailedLookupLocations): void;
5372    }
5373    export function createModuleResolutionCache(currentDirectory: string, getCanonicalFileName: (s: string) => string, options?: CompilerOptions): ModuleResolutionCache;
5374    export function createTypeReferenceDirectiveResolutionCache(currentDirectory: string, getCanonicalFileName: (s: string) => string, options?: CompilerOptions, packageJsonInfoCache?: PackageJsonInfoCache): TypeReferenceDirectiveResolutionCache;
5375    export function resolveModuleNameFromCache(moduleName: string, containingFile: string, cache: ModuleResolutionCache, mode?: ModuleKind.CommonJS | ModuleKind.ESNext): ResolvedModuleWithFailedLookupLocations | undefined;
5376    export function resolveModuleName(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache, redirectedReference?: ResolvedProjectReference, resolutionMode?: ModuleKind.CommonJS | ModuleKind.ESNext): ResolvedModuleWithFailedLookupLocations;
5377    export function nodeModuleNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache, redirectedReference?: ResolvedProjectReference): ResolvedModuleWithFailedLookupLocations;
5378    /**
5379     * This will be called on the successfully resolved path from `loadModuleFromFile`.
5380     * (Not needed for `loadModuleFromNodeModules` as that looks up the `package.json` or `oh-package.json5` as part of resolution.)
5381     *
5382     * packageDirectory is the directory of the package itself.
5383     *   For `blah/node_modules/foo/index.d.ts` this is packageDirectory: "foo"
5384     *   For `/node_modules/foo/bar.d.ts` this is packageDirectory: "foo"
5385     *   For `/node_modules/@types/foo/bar/index.d.ts` this is packageDirectory: "@types/foo"
5386     *   For `/node_modules/foo/bar/index.d.ts` this is packageDirectory: "foo"
5387     */
5388    export function parseModuleFromPath(resolved: string, packageManagerType?: string): string | undefined;
5389    export function classicNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: NonRelativeModuleNameResolutionCache, redirectedReference?: ResolvedProjectReference): ResolvedModuleWithFailedLookupLocations;
5390    export {};
5391}
5392declare namespace ts {
5393    function concatenateDecoratorsAndModifiers(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined): readonly ModifierLike[] | undefined;
5394    function isEtsFunctionDecorators(name: string | undefined, options: CompilerOptions): boolean;
5395    function isOhpm(packageManagerType: string | undefined): boolean;
5396    const ohModulesPathPart: string;
5397    function isOHModules(modulePath: string): boolean;
5398    function isOhpmAndOhModules(packageManagerType: string | undefined, modulePath: string): boolean;
5399    function getModulePathPartByPMType(packageManagerType: string | undefined): string;
5400    function getModuleByPMType(packageManagerType: string | undefined): string;
5401    function getPackageJsonByPMType(packageManagerType: string | undefined): string;
5402    function isOHModulesDirectory(dirPath: Path): boolean;
5403    function isTargetModulesDerectory(dirPath: Path): boolean;
5404    function pathContainsOHModules(path: string): boolean;
5405    function choosePathContainsModules(packageManagerType: string | undefined, fileName: string): boolean;
5406    function getTypeExportImportAndConstEnumTransformer(context: TransformationContext): (node: SourceFile) => SourceFile;
5407    /**
5408     * Add 'type' flag to import/export when import/export an type member.
5409     * Replace const enum with number and string literal.
5410     */
5411    function transformTypeExportImportAndConstEnumInTypeScript(context: TransformationContext): (node: SourceFile) => SourceFile;
5412    function hasTsNoCheckOrTsIgnoreFlag(node: SourceFile): boolean;
5413    function createObfTextSingleLineWriter(): EmitTextWriter;
5414}
5415declare namespace ts {
5416    /**
5417     * Visits a Node using the supplied visitor, possibly returning a new Node in its place.
5418     *
5419     * @param node The Node to visit.
5420     * @param visitor The callback used to visit the Node.
5421     * @param test A callback to execute to verify the Node is valid.
5422     * @param lift An optional callback to execute to lift a NodeArray into a valid Node.
5423     */
5424    function visitNode<T extends Node>(node: T, visitor: Visitor | undefined, test?: (node: Node) => boolean, lift?: (node: readonly Node[]) => T): T;
5425    /**
5426     * Visits a Node using the supplied visitor, possibly returning a new Node in its place.
5427     *
5428     * @param node The Node to visit.
5429     * @param visitor The callback used to visit the Node.
5430     * @param test A callback to execute to verify the Node is valid.
5431     * @param lift An optional callback to execute to lift a NodeArray into a valid Node.
5432     */
5433    function visitNode<T extends Node>(node: T | undefined, visitor: Visitor | undefined, test?: (node: Node) => boolean, lift?: (node: readonly Node[]) => T): T | undefined;
5434    /**
5435     * Visits a NodeArray using the supplied visitor, possibly returning a new NodeArray in its place.
5436     *
5437     * @param nodes The NodeArray to visit.
5438     * @param visitor The callback used to visit a Node.
5439     * @param test A node test to execute for each node.
5440     * @param start An optional value indicating the starting offset at which to start visiting.
5441     * @param count An optional value indicating the maximum number of nodes to visit.
5442     */
5443    function visitNodes<T extends Node>(nodes: NodeArray<T>, visitor: Visitor | undefined, test?: (node: Node) => boolean, start?: number, count?: number): NodeArray<T>;
5444    /**
5445     * Visits a NodeArray using the supplied visitor, possibly returning a new NodeArray in its place.
5446     *
5447     * @param nodes The NodeArray to visit.
5448     * @param visitor The callback used to visit a Node.
5449     * @param test A node test to execute for each node.
5450     * @param start An optional value indicating the starting offset at which to start visiting.
5451     * @param count An optional value indicating the maximum number of nodes to visit.
5452     */
5453    function visitNodes<T extends Node>(nodes: NodeArray<T> | undefined, visitor: Visitor | undefined, test?: (node: Node) => boolean, start?: number, count?: number): NodeArray<T> | undefined;
5454    /**
5455     * Starts a new lexical environment and visits a statement list, ending the lexical environment
5456     * and merging hoisted declarations upon completion.
5457     */
5458    function visitLexicalEnvironment(statements: NodeArray<Statement>, visitor: Visitor, context: TransformationContext, start?: number, ensureUseStrict?: boolean, nodesVisitor?: NodesVisitor): NodeArray<Statement>;
5459    /**
5460     * Starts a new lexical environment and visits a parameter list, suspending the lexical
5461     * environment upon completion.
5462     */
5463    function visitParameterList(nodes: NodeArray<ParameterDeclaration>, visitor: Visitor, context: TransformationContext, nodesVisitor?: NodesVisitor): NodeArray<ParameterDeclaration>;
5464    function visitParameterList(nodes: NodeArray<ParameterDeclaration> | undefined, visitor: Visitor, context: TransformationContext, nodesVisitor?: NodesVisitor): NodeArray<ParameterDeclaration> | undefined;
5465    /**
5466     * Resumes a suspended lexical environment and visits a function body, ending the lexical
5467     * environment and merging hoisted declarations upon completion.
5468     */
5469    function visitFunctionBody(node: FunctionBody, visitor: Visitor, context: TransformationContext): FunctionBody;
5470    /**
5471     * Resumes a suspended lexical environment and visits a function body, ending the lexical
5472     * environment and merging hoisted declarations upon completion.
5473     */
5474    function visitFunctionBody(node: FunctionBody | undefined, visitor: Visitor, context: TransformationContext): FunctionBody | undefined;
5475    /**
5476     * Resumes a suspended lexical environment and visits a concise body, ending the lexical
5477     * environment and merging hoisted declarations upon completion.
5478     */
5479    function visitFunctionBody(node: ConciseBody, visitor: Visitor, context: TransformationContext): ConciseBody;
5480    /**
5481     * Visits an iteration body, adding any block-scoped variables required by the transformation.
5482     */
5483    function visitIterationBody(body: Statement, visitor: Visitor, context: TransformationContext): Statement;
5484    /**
5485     * Visits each child of a Node using the supplied visitor, possibly returning a new Node of the same kind in its place.
5486     *
5487     * @param node The Node whose children will be visited.
5488     * @param visitor The callback used to visit each child.
5489     * @param context A lexical environment context for the visitor.
5490     */
5491    function visitEachChild<T extends Node>(node: T, visitor: Visitor, context: TransformationContext): T;
5492    /**
5493     * Visits each child of a Node using the supplied visitor, possibly returning a new Node of the same kind in its place.
5494     *
5495     * @param node The Node whose children will be visited.
5496     * @param visitor The callback used to visit each child.
5497     * @param context A lexical environment context for the visitor.
5498     */
5499    function visitEachChild<T extends Node>(node: T | undefined, visitor: Visitor, context: TransformationContext, nodesVisitor?: typeof visitNodes, tokenVisitor?: Visitor): T | undefined;
5500}
5501declare namespace ts {
5502    interface SourceMapGeneratorOptions {
5503        extendedDiagnostics?: boolean;
5504    }
5505    function createSourceMapGenerator(host: EmitHost, file: string, sourceRoot: string, sourcesDirectoryPath: string, generatorOptions: SourceMapGeneratorOptions): SourceMapGenerator;
5506}
5507declare namespace ts {
5508    function getTsBuildInfoEmitOutputFilePath(options: CompilerOptions): string | undefined;
5509    function getOutputFileNames(commandLine: ParsedCommandLine, inputFileName: string, ignoreCase: boolean): readonly string[];
5510    function createPrinter(printerOptions?: PrinterOptions, handlers?: PrintHandlers): Printer;
5511}
5512declare namespace ts {
5513    export function findConfigFile(searchPath: string, fileExists: (fileName: string) => boolean, configName?: string): string | undefined;
5514    export function resolveTripleslashReference(moduleName: string, containingFile: string): string;
5515    export function createCompilerHost(options: CompilerOptions, setParentNodes?: boolean): CompilerHost;
5516    export function getPreEmitDiagnostics(program: Program, sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly Diagnostic[];
5517    export interface FormatDiagnosticsHost {
5518        getCurrentDirectory(): string;
5519        getCanonicalFileName(fileName: string): string;
5520        getNewLine(): string;
5521    }
5522    export function formatDiagnostics(diagnostics: readonly Diagnostic[], host: FormatDiagnosticsHost): string;
5523    export function formatDiagnostic(diagnostic: Diagnostic, host: FormatDiagnosticsHost): string;
5524    export function formatDiagnosticsWithColorAndContext(diagnostics: readonly Diagnostic[], host: FormatDiagnosticsHost): string;
5525    export function flattenDiagnosticMessageText(diag: string | DiagnosticMessageChain | undefined, newLine: string, indent?: number): string;
5526    /**
5527     * Calculates the resulting resolution mode for some reference in some file - this is generally the explicitly
5528     * provided resolution mode in the reference, unless one is not present, in which case it is the mode of the containing file.
5529     */
5530    export function getModeForFileReference(ref: FileReference | string, containingFileMode: SourceFile["impliedNodeFormat"]): ModuleKind.CommonJS | ModuleKind.ESNext | undefined;
5531    /**
5532     * Calculates the final resolution mode for an import at some index within a file's imports list. This is generally the explicitly
5533     * defined mode of the import if provided, or, if not, the mode of the containing file (with some exceptions: import=require is always commonjs, dynamic import is always esm).
5534     * If you have an actual import node, prefer using getModeForUsageLocation on the reference string node.
5535     * @param file File to fetch the resolution mode within
5536     * @param index Index into the file's complete resolution list to get the resolution of - this is a concatenation of the file's imports and module augmentations
5537     */
5538    export function getModeForResolutionAtIndex(file: SourceFile, index: number): ModuleKind.CommonJS | ModuleKind.ESNext | undefined;
5539    /**
5540     * Calculates the final resolution mode for a given module reference node. This is generally the explicitly provided resolution mode, if
5541     * one exists, or the mode of the containing source file. (Excepting import=require, which is always commonjs, and dynamic import, which is always esm).
5542     * Notably, this function always returns `undefined` if the containing file has an `undefined` `impliedNodeFormat` - this field is only set when
5543     * `moduleResolution` is `node16`+.
5544     * @param file The file the import or import-like reference is contained within
5545     * @param usage The module reference string
5546     * @returns The final resolution mode of the import
5547     */
5548    export function getModeForUsageLocation(file: {
5549        impliedNodeFormat?: SourceFile["impliedNodeFormat"];
5550    }, usage: StringLiteralLike): ModuleKind.CommonJS | ModuleKind.ESNext | undefined;
5551    export function getConfigFileParsingDiagnostics(configFileParseResult: ParsedCommandLine): readonly Diagnostic[];
5552    /**
5553     * A function for determining if a given file is esm or cjs format, assuming modern node module resolution rules, as configured by the
5554     * `options` parameter.
5555     *
5556     * @param fileName The normalized absolute path to check the format of (it need not exist on disk)
5557     * @param [packageJsonInfoCache] A cache for package file lookups - it's best to have a cache when this function is called often
5558     * @param host The ModuleResolutionHost which can perform the filesystem lookups for package json data
5559     * @param options The compiler options to perform the analysis under - relevant options are `moduleResolution` and `traceResolution`
5560     * @returns `undefined` if the path has no relevant implied format, `ModuleKind.ESNext` for esm format, and `ModuleKind.CommonJS` for cjs format
5561     */
5562    export function getImpliedNodeFormatForFile(fileName: Path, packageJsonInfoCache: PackageJsonInfoCache | undefined, host: ModuleResolutionHost, options: CompilerOptions): ModuleKind.ESNext | ModuleKind.CommonJS | undefined;
5563    /**
5564     * Create a new 'Program' instance. A Program is an immutable collection of 'SourceFile's and a 'CompilerOptions'
5565     * that represent a compilation unit.
5566     *
5567     * Creating a program proceeds from a set of root files, expanding the set of inputs by following imports and
5568     * triple-slash-reference-path directives transitively. '@types' and triple-slash-reference-types are also pulled in.
5569     *
5570     * @param createProgramOptions - The options for creating a program.
5571     * @returns A 'Program' object.
5572     */
5573    export function createProgram(createProgramOptions: CreateProgramOptions): Program;
5574    /**
5575     * Create a new 'Program' instance. A Program is an immutable collection of 'SourceFile's and a 'CompilerOptions'
5576     * that represent a compilation unit.
5577     *
5578     * Creating a program proceeds from a set of root files, expanding the set of inputs by following imports and
5579     * triple-slash-reference-path directives transitively. '@types' and triple-slash-reference-types are also pulled in.
5580     *
5581     * @param rootNames - A set of root files.
5582     * @param options - The compiler options which should be used.
5583     * @param host - The host interacts with the underlying file system.
5584     * @param oldProgram - Reuses an old program structure.
5585     * @param configFileParsingDiagnostics - error during config file parsing
5586     * @returns A 'Program' object.
5587     */
5588    export function createProgram(rootNames: readonly string[], options: CompilerOptions, host?: CompilerHost, oldProgram?: Program, configFileParsingDiagnostics?: readonly Diagnostic[]): Program;
5589    /** @deprecated */ export interface ResolveProjectReferencePathHost {
5590        fileExists(fileName: string): boolean;
5591    }
5592    /**
5593     * Returns the target config filename of a project reference.
5594     * Note: The file might not exist.
5595     */
5596    export function resolveProjectReferencePath(ref: ProjectReference): ResolvedConfigFileName;
5597    /** @deprecated */ export function resolveProjectReferencePath(host: ResolveProjectReferencePathHost, ref: ProjectReference): ResolvedConfigFileName;
5598    export {};
5599}
5600declare namespace ts {
5601    interface EmitOutput {
5602        outputFiles: OutputFile[];
5603        emitSkipped: boolean;
5604    }
5605    interface OutputFile {
5606        name: string;
5607        writeByteOrderMark: boolean;
5608        text: string;
5609    }
5610}
5611declare namespace ts {
5612    type AffectedFileResult<T> = {
5613        result: T;
5614        affected: SourceFile | Program;
5615    } | undefined;
5616    interface BuilderProgramHost {
5617        /**
5618         * return true if file names are treated with case sensitivity
5619         */
5620        useCaseSensitiveFileNames(): boolean;
5621        /**
5622         * If provided this would be used this hash instead of actual file shape text for detecting changes
5623         */
5624        createHash?: (data: string) => string;
5625        /**
5626         * When emit or emitNextAffectedFile are called without writeFile,
5627         * this callback if present would be used to write files
5628         */
5629        writeFile?: WriteFileCallback;
5630    }
5631    /**
5632     * Builder to manage the program state changes
5633     */
5634    interface BuilderProgram {
5635        /**
5636         * Returns current program
5637         */
5638        getProgram(): Program;
5639        /**
5640         * Get compiler options of the program
5641         */
5642        getCompilerOptions(): CompilerOptions;
5643        /**
5644         * Get the source file in the program with file name
5645         */
5646        getSourceFile(fileName: string): SourceFile | undefined;
5647        /**
5648         * Get a list of files in the program
5649         */
5650        getSourceFiles(): readonly SourceFile[];
5651        /**
5652         * Get the diagnostics for compiler options
5653         */
5654        getOptionsDiagnostics(cancellationToken?: CancellationToken): readonly Diagnostic[];
5655        /**
5656         * Get the diagnostics that dont belong to any file
5657         */
5658        getGlobalDiagnostics(cancellationToken?: CancellationToken): readonly Diagnostic[];
5659        /**
5660         * Get the diagnostics from config file parsing
5661         */
5662        getConfigFileParsingDiagnostics(): readonly Diagnostic[];
5663        /**
5664         * Get the syntax diagnostics, for all source files if source file is not supplied
5665         */
5666        getSyntacticDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly Diagnostic[];
5667        /**
5668         * Get the declaration diagnostics, for all source files if source file is not supplied
5669         */
5670        getDeclarationDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly DiagnosticWithLocation[];
5671        /**
5672         * Get all the dependencies of the file
5673         */
5674        getAllDependencies(sourceFile: SourceFile): readonly string[];
5675        /**
5676         * Gets the semantic diagnostics from the program corresponding to this state of file (if provided) or whole program
5677         * The semantic diagnostics are cached and managed here
5678         * Note that it is assumed that when asked about semantic diagnostics through this API,
5679         * the file has been taken out of affected files so it is safe to use cache or get from program and cache the diagnostics
5680         * In case of SemanticDiagnosticsBuilderProgram if the source file is not provided,
5681         * it will iterate through all the affected files, to ensure that cache stays valid and yet provide a way to get all semantic diagnostics
5682         */
5683        getSemanticDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly Diagnostic[];
5684        /**
5685         * Emits the JavaScript and declaration files.
5686         * When targetSource file is specified, emits the files corresponding to that source file,
5687         * otherwise for the whole program.
5688         * In case of EmitAndSemanticDiagnosticsBuilderProgram, when targetSourceFile is specified,
5689         * it is assumed that that file is handled from affected file list. If targetSourceFile is not specified,
5690         * it will only emit all the affected files instead of whole program
5691         *
5692         * The first of writeFile if provided, writeFile of BuilderProgramHost if provided, writeFile of compiler host
5693         * in that order would be used to write the files
5694         */
5695        emit(targetSourceFile?: SourceFile, writeFile?: WriteFileCallback, cancellationToken?: CancellationToken, emitOnlyDtsFiles?: boolean, customTransformers?: CustomTransformers): EmitResult;
5696        /**
5697         * Get the current directory of the program
5698         */
5699        getCurrentDirectory(): string;
5700    }
5701    /**
5702     * The builder that caches the semantic diagnostics for the program and handles the changed files and affected files
5703     */
5704    interface SemanticDiagnosticsBuilderProgram extends BuilderProgram {
5705        /**
5706         * Gets the semantic diagnostics from the program for the next affected file and caches it
5707         * Returns undefined if the iteration is complete
5708         */
5709        getSemanticDiagnosticsOfNextAffectedFile(cancellationToken?: CancellationToken, ignoreSourceFile?: (sourceFile: SourceFile) => boolean): AffectedFileResult<readonly Diagnostic[]>;
5710    }
5711    /**
5712     * The builder that can handle the changes in program and iterate through changed file to emit the files
5713     * The semantic diagnostics are cached per file and managed by clearing for the changed/affected files
5714     */
5715    interface EmitAndSemanticDiagnosticsBuilderProgram extends SemanticDiagnosticsBuilderProgram {
5716        /**
5717         * Emits the next affected file's emit result (EmitResult and sourceFiles emitted) or returns undefined if iteration is complete
5718         * The first of writeFile if provided, writeFile of BuilderProgramHost if provided, writeFile of compiler host
5719         * in that order would be used to write the files
5720         */
5721        emitNextAffectedFile(writeFile?: WriteFileCallback, cancellationToken?: CancellationToken, emitOnlyDtsFiles?: boolean, customTransformers?: CustomTransformers): AffectedFileResult<EmitResult>;
5722    }
5723    /**
5724     * Create the builder to manage semantic diagnostics and cache them
5725     */
5726    function createSemanticDiagnosticsBuilderProgram(newProgram: Program, host: BuilderProgramHost, oldProgram?: SemanticDiagnosticsBuilderProgram, configFileParsingDiagnostics?: readonly Diagnostic[]): SemanticDiagnosticsBuilderProgram;
5727    function createSemanticDiagnosticsBuilderProgram(rootNames: readonly string[] | undefined, options: CompilerOptions | undefined, host?: CompilerHost, oldProgram?: SemanticDiagnosticsBuilderProgram, configFileParsingDiagnostics?: readonly Diagnostic[], projectReferences?: readonly ProjectReference[]): SemanticDiagnosticsBuilderProgram;
5728    /**
5729     * Create the builder that can handle the changes in program and iterate through changed files
5730     * to emit the those files and manage semantic diagnostics cache as well
5731     */
5732    function createEmitAndSemanticDiagnosticsBuilderProgram(newProgram: Program, host: BuilderProgramHost, oldProgram?: EmitAndSemanticDiagnosticsBuilderProgram, configFileParsingDiagnostics?: readonly Diagnostic[]): EmitAndSemanticDiagnosticsBuilderProgram;
5733    function createEmitAndSemanticDiagnosticsBuilderProgram(rootNames: readonly string[] | undefined, options: CompilerOptions | undefined, host?: CompilerHost, oldProgram?: EmitAndSemanticDiagnosticsBuilderProgram, configFileParsingDiagnostics?: readonly Diagnostic[], projectReferences?: readonly ProjectReference[]): EmitAndSemanticDiagnosticsBuilderProgram;
5734    /**
5735     * Creates a builder thats just abstraction over program and can be used with watch
5736     */
5737    function createAbstractBuilder(newProgram: Program, host: BuilderProgramHost, oldProgram?: BuilderProgram, configFileParsingDiagnostics?: readonly Diagnostic[]): BuilderProgram;
5738    function createAbstractBuilder(rootNames: readonly string[] | undefined, options: CompilerOptions | undefined, host?: CompilerHost, oldProgram?: BuilderProgram, configFileParsingDiagnostics?: readonly Diagnostic[], projectReferences?: readonly ProjectReference[]): BuilderProgram;
5739}
5740declare namespace ts {
5741    interface ReadBuildProgramHost {
5742        useCaseSensitiveFileNames(): boolean;
5743        getCurrentDirectory(): string;
5744        readFile(fileName: string): string | undefined;
5745        getLastCompiledProgram?(): Program;
5746    }
5747    function readBuilderProgram(compilerOptions: CompilerOptions, host: ReadBuildProgramHost): EmitAndSemanticDiagnosticsBuilderProgram | undefined;
5748    function createIncrementalCompilerHost(options: CompilerOptions, system?: System): CompilerHost;
5749    interface IncrementalProgramOptions<T extends BuilderProgram> {
5750        rootNames: readonly string[];
5751        options: CompilerOptions;
5752        configFileParsingDiagnostics?: readonly Diagnostic[];
5753        projectReferences?: readonly ProjectReference[];
5754        host?: CompilerHost;
5755        createProgram?: CreateProgram<T>;
5756    }
5757    function createIncrementalProgram<T extends BuilderProgram = EmitAndSemanticDiagnosticsBuilderProgram>({ rootNames, options, configFileParsingDiagnostics, projectReferences, host, createProgram }: IncrementalProgramOptions<T>): T;
5758    type WatchStatusReporter = (diagnostic: Diagnostic, newLine: string, options: CompilerOptions, errorCount?: number) => void;
5759    /** Create the program with rootNames and options, if they are undefined, oldProgram and new configFile diagnostics create new program */
5760    type CreateProgram<T extends BuilderProgram> = (rootNames: readonly string[] | undefined, options: CompilerOptions | undefined, host?: CompilerHost, oldProgram?: T, configFileParsingDiagnostics?: readonly Diagnostic[], projectReferences?: readonly ProjectReference[] | undefined) => T;
5761    /** Host that has watch functionality used in --watch mode */
5762    interface WatchHost {
5763        /** If provided, called with Diagnostic message that informs about change in watch status */
5764        onWatchStatusChange?(diagnostic: Diagnostic, newLine: string, options: CompilerOptions, errorCount?: number): void;
5765        /** Used to watch changes in source files, missing files needed to update the program or config file */
5766        watchFile(path: string, callback: FileWatcherCallback, pollingInterval?: number, options?: WatchOptions): FileWatcher;
5767        /** Used to watch resolved module's failed lookup locations, config file specs, type roots where auto type reference directives are added */
5768        watchDirectory(path: string, callback: DirectoryWatcherCallback, recursive?: boolean, options?: WatchOptions): FileWatcher;
5769        /** If provided, will be used to set delayed compilation, so that multiple changes in short span are compiled together */
5770        setTimeout?(callback: (...args: any[]) => void, ms: number, ...args: any[]): any;
5771        /** If provided, will be used to reset existing delayed compilation */
5772        clearTimeout?(timeoutId: any): void;
5773    }
5774    interface ProgramHost<T extends BuilderProgram> {
5775        /**
5776         * Used to create the program when need for program creation or recreation detected
5777         */
5778        createProgram: CreateProgram<T>;
5779        useCaseSensitiveFileNames(): boolean;
5780        getNewLine(): string;
5781        getCurrentDirectory(): string;
5782        getDefaultLibFileName(options: CompilerOptions): string;
5783        getDefaultLibLocation?(): string;
5784        createHash?(data: string): string;
5785        /**
5786         * Use to check file presence for source files and
5787         * if resolveModuleNames is not provided (complier is in charge of module resolution) then module files as well
5788         */
5789        fileExists(path: string): boolean;
5790        /**
5791         * Use to read file text for source files and
5792         * if resolveModuleNames is not provided (complier is in charge of module resolution) then module files as well
5793         */
5794        readFile(path: string, encoding?: string): string | undefined;
5795        /** If provided, used for module resolution as well as to handle directory structure */
5796        directoryExists?(path: string): boolean;
5797        /** If provided, used in resolutions as well as handling directory structure */
5798        getDirectories?(path: string): string[];
5799        /** If provided, used to cache and handle directory structure modifications */
5800        readDirectory?(path: string, extensions?: readonly string[], exclude?: readonly string[], include?: readonly string[], depth?: number): string[];
5801        /** Symbol links resolution */
5802        realpath?(path: string): string;
5803        /** If provided would be used to write log about compilation */
5804        trace?(s: string): void;
5805        /** If provided is used to get the environment variable */
5806        getEnvironmentVariable?(name: string): string | undefined;
5807        /** If provided, used to resolve the module names, otherwise typescript's default module resolution */
5808        resolveModuleNames?(moduleNames: string[], containingFile: string, reusedNames: string[] | undefined, redirectedReference: ResolvedProjectReference | undefined, options: CompilerOptions, containingSourceFile?: SourceFile): (ResolvedModule | undefined)[];
5809        /** If provided, used to resolve type reference directives, otherwise typescript's default resolution */
5810        resolveTypeReferenceDirectives?(typeReferenceDirectiveNames: string[] | readonly FileReference[], containingFile: string, redirectedReference: ResolvedProjectReference | undefined, options: CompilerOptions, containingFileMode?: SourceFile["impliedNodeFormat"] | undefined): (ResolvedTypeReferenceDirective | undefined)[];
5811        /** If provided along with custom resolveModuleNames or resolveTypeReferenceDirectives, used to determine if unchanged file path needs to re-resolve modules/type reference directives */
5812        hasInvalidatedResolutions?(filePath: Path): boolean;
5813        /**
5814         * 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
5815         */
5816        getModuleResolutionCache?(): ModuleResolutionCache | undefined;
5817    }
5818    interface WatchCompilerHost<T extends BuilderProgram> extends ProgramHost<T>, WatchHost {
5819        /** Instead of using output d.ts file from project reference, use its source file */
5820        useSourceOfProjectReferenceRedirect?(): boolean;
5821        /** If provided, use this method to get parsed command lines for referenced projects */
5822        getParsedCommandLine?(fileName: string): ParsedCommandLine | undefined;
5823        /** If provided, callback to invoke after every new program creation */
5824        afterProgramCreate?(program: T): void;
5825    }
5826    /**
5827     * Host to create watch with root files and options
5828     */
5829    interface WatchCompilerHostOfFilesAndCompilerOptions<T extends BuilderProgram> extends WatchCompilerHost<T> {
5830        /** root files to use to generate program */
5831        rootFiles: string[];
5832        /** Compiler options */
5833        options: CompilerOptions;
5834        watchOptions?: WatchOptions;
5835        /** Project References */
5836        projectReferences?: readonly ProjectReference[];
5837    }
5838    /**
5839     * Host to create watch with config file
5840     */
5841    interface WatchCompilerHostOfConfigFile<T extends BuilderProgram> extends WatchCompilerHost<T>, ConfigFileDiagnosticsReporter {
5842        /** Name of the config file to compile */
5843        configFileName: string;
5844        /** Options to extend */
5845        optionsToExtend?: CompilerOptions;
5846        watchOptionsToExtend?: WatchOptions;
5847        extraFileExtensions?: readonly FileExtensionInfo[];
5848        /**
5849         * Used to generate source file names from the config file and its include, exclude, files rules
5850         * and also to cache the directory stucture
5851         */
5852        readDirectory(path: string, extensions?: readonly string[], exclude?: readonly string[], include?: readonly string[], depth?: number): string[];
5853    }
5854    interface Watch<T> {
5855        /** Synchronize with host and get updated program */
5856        getProgram(): T;
5857        /** Closes the watch */
5858        close(): void;
5859    }
5860    /**
5861     * Creates the watch what generates program using the config file
5862     */
5863    interface WatchOfConfigFile<T> extends Watch<T> {
5864    }
5865    /**
5866     * Creates the watch that generates program using the root files and compiler options
5867     */
5868    interface WatchOfFilesAndCompilerOptions<T> extends Watch<T> {
5869        /** Updates the root files in the program, only if this is not config file compilation */
5870        updateRootFileNames(fileNames: string[]): void;
5871    }
5872    /**
5873     * Create the watch compiler host for either configFile or fileNames and its options
5874     */
5875    function createWatchCompilerHost<T extends BuilderProgram>(configFileName: string, optionsToExtend: CompilerOptions | undefined, system: System, createProgram?: CreateProgram<T>, reportDiagnostic?: DiagnosticReporter, reportWatchStatus?: WatchStatusReporter, watchOptionsToExtend?: WatchOptions, extraFileExtensions?: readonly FileExtensionInfo[]): WatchCompilerHostOfConfigFile<T>;
5876    function createWatchCompilerHost<T extends BuilderProgram>(rootFiles: string[], options: CompilerOptions, system: System, createProgram?: CreateProgram<T>, reportDiagnostic?: DiagnosticReporter, reportWatchStatus?: WatchStatusReporter, projectReferences?: readonly ProjectReference[], watchOptions?: WatchOptions): WatchCompilerHostOfFilesAndCompilerOptions<T>;
5877    /**
5878     * Creates the watch from the host for root files and compiler options
5879     */
5880    function createWatchProgram<T extends BuilderProgram>(host: WatchCompilerHostOfFilesAndCompilerOptions<T>): WatchOfFilesAndCompilerOptions<T>;
5881    /**
5882     * Creates the watch from the host for config file
5883     */
5884    function createWatchProgram<T extends BuilderProgram>(host: WatchCompilerHostOfConfigFile<T>): WatchOfConfigFile<T>;
5885}
5886declare namespace ts {
5887    interface BuildOptions {
5888        dry?: boolean;
5889        force?: boolean;
5890        verbose?: boolean;
5891        incremental?: boolean;
5892        assumeChangesOnlyAffectDirectDependencies?: boolean;
5893        traceResolution?: boolean;
5894        [option: string]: CompilerOptionsValue | undefined;
5895    }
5896    type ReportEmitErrorSummary = (errorCount: number, filesInError: (ReportFileInError | undefined)[]) => void;
5897    interface ReportFileInError {
5898        fileName: string;
5899        line: number;
5900    }
5901    interface SolutionBuilderHostBase<T extends BuilderProgram> extends ProgramHost<T> {
5902        createDirectory?(path: string): void;
5903        /**
5904         * Should provide create directory and writeFile if done of invalidatedProjects is not invoked with
5905         * writeFileCallback
5906         */
5907        writeFile?(path: string, data: string, writeByteOrderMark?: boolean): void;
5908        getCustomTransformers?: (project: string) => CustomTransformers | undefined;
5909        getModifiedTime(fileName: string): Date | undefined;
5910        setModifiedTime(fileName: string, date: Date): void;
5911        deleteFile(fileName: string): void;
5912        getParsedCommandLine?(fileName: string): ParsedCommandLine | undefined;
5913        reportDiagnostic: DiagnosticReporter;
5914        reportSolutionBuilderStatus: DiagnosticReporter;
5915        afterProgramEmitAndDiagnostics?(program: T): void;
5916    }
5917    interface SolutionBuilderHost<T extends BuilderProgram> extends SolutionBuilderHostBase<T> {
5918        reportErrorSummary?: ReportEmitErrorSummary;
5919    }
5920    interface SolutionBuilderWithWatchHost<T extends BuilderProgram> extends SolutionBuilderHostBase<T>, WatchHost {
5921    }
5922    interface SolutionBuilder<T extends BuilderProgram> {
5923        build(project?: string, cancellationToken?: CancellationToken, writeFile?: WriteFileCallback, getCustomTransformers?: (project: string) => CustomTransformers): ExitStatus;
5924        clean(project?: string): ExitStatus;
5925        buildReferences(project: string, cancellationToken?: CancellationToken, writeFile?: WriteFileCallback, getCustomTransformers?: (project: string) => CustomTransformers): ExitStatus;
5926        cleanReferences(project?: string): ExitStatus;
5927        getNextInvalidatedProject(cancellationToken?: CancellationToken): InvalidatedProject<T> | undefined;
5928    }
5929    /**
5930     * Create a function that reports watch status by writing to the system and handles the formating of the diagnostic
5931     */
5932    function createBuilderStatusReporter(system: System, pretty?: boolean): DiagnosticReporter;
5933    function createSolutionBuilderHost<T extends BuilderProgram = EmitAndSemanticDiagnosticsBuilderProgram>(system?: System, createProgram?: CreateProgram<T>, reportDiagnostic?: DiagnosticReporter, reportSolutionBuilderStatus?: DiagnosticReporter, reportErrorSummary?: ReportEmitErrorSummary): SolutionBuilderHost<T>;
5934    function createSolutionBuilderWithWatchHost<T extends BuilderProgram = EmitAndSemanticDiagnosticsBuilderProgram>(system?: System, createProgram?: CreateProgram<T>, reportDiagnostic?: DiagnosticReporter, reportSolutionBuilderStatus?: DiagnosticReporter, reportWatchStatus?: WatchStatusReporter): SolutionBuilderWithWatchHost<T>;
5935    function createSolutionBuilder<T extends BuilderProgram>(host: SolutionBuilderHost<T>, rootNames: readonly string[], defaultOptions: BuildOptions): SolutionBuilder<T>;
5936    function createSolutionBuilderWithWatch<T extends BuilderProgram>(host: SolutionBuilderWithWatchHost<T>, rootNames: readonly string[], defaultOptions: BuildOptions, baseWatchOptions?: WatchOptions): SolutionBuilder<T>;
5937    enum InvalidatedProjectKind {
5938        Build = 0,
5939        UpdateBundle = 1,
5940        UpdateOutputFileStamps = 2
5941    }
5942    interface InvalidatedProjectBase {
5943        readonly kind: InvalidatedProjectKind;
5944        readonly project: ResolvedConfigFileName;
5945        /**
5946         *  To dispose this project and ensure that all the necessary actions are taken and state is updated accordingly
5947         */
5948        done(cancellationToken?: CancellationToken, writeFile?: WriteFileCallback, customTransformers?: CustomTransformers): ExitStatus;
5949        getCompilerOptions(): CompilerOptions;
5950        getCurrentDirectory(): string;
5951    }
5952    interface UpdateOutputFileStampsProject extends InvalidatedProjectBase {
5953        readonly kind: InvalidatedProjectKind.UpdateOutputFileStamps;
5954        updateOutputFileStatmps(): void;
5955    }
5956    interface BuildInvalidedProject<T extends BuilderProgram> extends InvalidatedProjectBase {
5957        readonly kind: InvalidatedProjectKind.Build;
5958        getBuilderProgram(): T | undefined;
5959        getProgram(): Program | undefined;
5960        getSourceFile(fileName: string): SourceFile | undefined;
5961        getSourceFiles(): readonly SourceFile[];
5962        getOptionsDiagnostics(cancellationToken?: CancellationToken): readonly Diagnostic[];
5963        getGlobalDiagnostics(cancellationToken?: CancellationToken): readonly Diagnostic[];
5964        getConfigFileParsingDiagnostics(): readonly Diagnostic[];
5965        getSyntacticDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly Diagnostic[];
5966        getAllDependencies(sourceFile: SourceFile): readonly string[];
5967        getSemanticDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly Diagnostic[];
5968        getSemanticDiagnosticsOfNextAffectedFile(cancellationToken?: CancellationToken, ignoreSourceFile?: (sourceFile: SourceFile) => boolean): AffectedFileResult<readonly Diagnostic[]>;
5969        emit(targetSourceFile?: SourceFile, writeFile?: WriteFileCallback, cancellationToken?: CancellationToken, emitOnlyDtsFiles?: boolean, customTransformers?: CustomTransformers): EmitResult | undefined;
5970    }
5971    interface UpdateBundleProject<T extends BuilderProgram> extends InvalidatedProjectBase {
5972        readonly kind: InvalidatedProjectKind.UpdateBundle;
5973        emit(writeFile?: WriteFileCallback, customTransformers?: CustomTransformers): EmitResult | BuildInvalidedProject<T> | undefined;
5974    }
5975    type InvalidatedProject<T extends BuilderProgram> = UpdateOutputFileStampsProject | BuildInvalidedProject<T> | UpdateBundleProject<T>;
5976}
5977declare namespace ts.server {
5978    type ActionSet = "action::set";
5979    type ActionInvalidate = "action::invalidate";
5980    type ActionPackageInstalled = "action::packageInstalled";
5981    type EventTypesRegistry = "event::typesRegistry";
5982    type EventBeginInstallTypes = "event::beginInstallTypes";
5983    type EventEndInstallTypes = "event::endInstallTypes";
5984    type EventInitializationFailed = "event::initializationFailed";
5985}
5986declare namespace ts.server {
5987    interface TypingInstallerResponse {
5988        readonly kind: ActionSet | ActionInvalidate | EventTypesRegistry | ActionPackageInstalled | EventBeginInstallTypes | EventEndInstallTypes | EventInitializationFailed;
5989    }
5990    interface TypingInstallerRequestWithProjectName {
5991        readonly projectName: string;
5992    }
5993    interface DiscoverTypings extends TypingInstallerRequestWithProjectName {
5994        readonly fileNames: string[];
5995        readonly projectRootPath: Path;
5996        readonly compilerOptions: CompilerOptions;
5997        readonly watchOptions?: WatchOptions;
5998        readonly typeAcquisition: TypeAcquisition;
5999        readonly unresolvedImports: SortedReadonlyArray<string>;
6000        readonly cachePath?: string;
6001        readonly kind: "discover";
6002    }
6003    interface CloseProject extends TypingInstallerRequestWithProjectName {
6004        readonly kind: "closeProject";
6005    }
6006    interface TypesRegistryRequest {
6007        readonly kind: "typesRegistry";
6008    }
6009    interface InstallPackageRequest extends TypingInstallerRequestWithProjectName {
6010        readonly kind: "installPackage";
6011        readonly fileName: Path;
6012        readonly packageName: string;
6013        readonly projectRootPath: Path;
6014    }
6015    interface PackageInstalledResponse extends ProjectResponse {
6016        readonly kind: ActionPackageInstalled;
6017        readonly success: boolean;
6018        readonly message: string;
6019    }
6020    interface InitializationFailedResponse extends TypingInstallerResponse {
6021        readonly kind: EventInitializationFailed;
6022        readonly message: string;
6023        readonly stack?: string;
6024    }
6025    interface ProjectResponse extends TypingInstallerResponse {
6026        readonly projectName: string;
6027    }
6028    interface InvalidateCachedTypings extends ProjectResponse {
6029        readonly kind: ActionInvalidate;
6030    }
6031    interface InstallTypes extends ProjectResponse {
6032        readonly kind: EventBeginInstallTypes | EventEndInstallTypes;
6033        readonly eventId: number;
6034        readonly typingsInstallerVersion: string;
6035        readonly packagesToInstall: readonly string[];
6036    }
6037    interface BeginInstallTypes extends InstallTypes {
6038        readonly kind: EventBeginInstallTypes;
6039    }
6040    interface EndInstallTypes extends InstallTypes {
6041        readonly kind: EventEndInstallTypes;
6042        readonly installSuccess: boolean;
6043    }
6044    interface SetTypings extends ProjectResponse {
6045        readonly typeAcquisition: TypeAcquisition;
6046        readonly compilerOptions: CompilerOptions;
6047        readonly typings: string[];
6048        readonly unresolvedImports: SortedReadonlyArray<string>;
6049        readonly kind: ActionSet;
6050    }
6051}
6052declare namespace ts {
6053    interface Node {
6054        getSourceFile(): SourceFile;
6055        getChildCount(sourceFile?: SourceFile): number;
6056        getChildAt(index: number, sourceFile?: SourceFile): Node;
6057        getChildren(sourceFile?: SourceFile): Node[];
6058        getStart(sourceFile?: SourceFile, includeJsDocComment?: boolean): number;
6059        getFullStart(): number;
6060        getEnd(): number;
6061        getWidth(sourceFile?: SourceFileLike): number;
6062        getFullWidth(): number;
6063        getLeadingTriviaWidth(sourceFile?: SourceFile): number;
6064        getFullText(sourceFile?: SourceFile): string;
6065        getText(sourceFile?: SourceFile): string;
6066        getFirstToken(sourceFile?: SourceFile): Node | undefined;
6067        getLastToken(sourceFile?: SourceFile): Node | undefined;
6068        forEachChild<T>(cbNode: (node: Node) => T | undefined, cbNodeArray?: (nodes: NodeArray<Node>) => T | undefined): T | undefined;
6069    }
6070    interface Identifier {
6071        readonly text: string;
6072    }
6073    interface PrivateIdentifier {
6074        readonly text: string;
6075    }
6076    interface Symbol {
6077        readonly name: string;
6078        getFlags(): SymbolFlags;
6079        getEscapedName(): __String;
6080        getName(): string;
6081        getDeclarations(): Declaration[] | undefined;
6082        getDocumentationComment(typeChecker: TypeChecker | undefined): SymbolDisplayPart[];
6083        getJsDocTags(checker?: TypeChecker): JSDocTagInfo[];
6084    }
6085    interface Type {
6086        getFlags(): TypeFlags;
6087        getSymbol(): Symbol | undefined;
6088        getProperties(): Symbol[];
6089        getProperty(propertyName: string): Symbol | undefined;
6090        getApparentProperties(): Symbol[];
6091        getCallSignatures(): readonly Signature[];
6092        getConstructSignatures(): readonly Signature[];
6093        getStringIndexType(): Type | undefined;
6094        getNumberIndexType(): Type | undefined;
6095        getBaseTypes(): BaseType[] | undefined;
6096        getNonNullableType(): Type;
6097        getConstraint(): Type | undefined;
6098        getDefault(): Type | undefined;
6099        isUnion(): this is UnionType;
6100        isIntersection(): this is IntersectionType;
6101        isUnionOrIntersection(): this is UnionOrIntersectionType;
6102        isLiteral(): this is LiteralType;
6103        isStringLiteral(): this is StringLiteralType;
6104        isNumberLiteral(): this is NumberLiteralType;
6105        isTypeParameter(): this is TypeParameter;
6106        isClassOrInterface(): this is InterfaceType;
6107        isClass(): this is InterfaceType;
6108        isIndexType(): this is IndexType;
6109    }
6110    interface TypeReference {
6111        typeArguments?: readonly Type[];
6112    }
6113    interface Signature {
6114        getDeclaration(): SignatureDeclaration;
6115        getTypeParameters(): TypeParameter[] | undefined;
6116        getParameters(): Symbol[];
6117        getTypeParameterAtPosition(pos: number): Type;
6118        getReturnType(): Type;
6119        getDocumentationComment(typeChecker: TypeChecker | undefined): SymbolDisplayPart[];
6120        getJsDocTags(): JSDocTagInfo[];
6121    }
6122    interface SourceFile {
6123        getLineAndCharacterOfPosition(pos: number): LineAndCharacter;
6124        getLineEndOfPosition(pos: number): number;
6125        getLineStarts(): readonly number[];
6126        getPositionOfLineAndCharacter(line: number, character: number): number;
6127        update(newText: string, textChangeRange: TextChangeRange): SourceFile;
6128    }
6129    interface SourceFileLike {
6130        getLineAndCharacterOfPosition(pos: number): LineAndCharacter;
6131    }
6132    interface SourceMapSource {
6133        getLineAndCharacterOfPosition(pos: number): LineAndCharacter;
6134    }
6135    /**
6136     * Represents an immutable snapshot of a script at a specified time.Once acquired, the
6137     * snapshot is observably immutable. i.e. the same calls with the same parameters will return
6138     * the same values.
6139     */
6140    interface IScriptSnapshot {
6141        /** Gets a portion of the script snapshot specified by [start, end). */
6142        getText(start: number, end: number): string;
6143        /** Gets the length of this script snapshot. */
6144        getLength(): number;
6145        /**
6146         * Gets the TextChangeRange that describe how the text changed between this text and
6147         * an older version.  This information is used by the incremental parser to determine
6148         * what sections of the script need to be re-parsed.  'undefined' can be returned if the
6149         * change range cannot be determined.  However, in that case, incremental parsing will
6150         * not happen and the entire document will be re - parsed.
6151         */
6152        getChangeRange(oldSnapshot: IScriptSnapshot): TextChangeRange | undefined;
6153        /** Releases all resources held by this script snapshot */
6154        dispose?(): void;
6155    }
6156    namespace ScriptSnapshot {
6157        function fromString(text: string): IScriptSnapshot;
6158    }
6159    interface PreProcessedFileInfo {
6160        referencedFiles: FileReference[];
6161        typeReferenceDirectives: FileReference[];
6162        libReferenceDirectives: FileReference[];
6163        importedFiles: FileReference[];
6164        ambientExternalModules?: string[];
6165        isLibFile: boolean;
6166    }
6167    interface HostCancellationToken {
6168        isCancellationRequested(): boolean;
6169    }
6170    interface InstallPackageOptions {
6171        fileName: Path;
6172        packageName: string;
6173    }
6174    interface PerformanceEvent {
6175        kind: "UpdateGraph" | "CreatePackageJsonAutoImportProvider";
6176        durationMs: number;
6177    }
6178    enum LanguageServiceMode {
6179        Semantic = 0,
6180        PartialSemantic = 1,
6181        Syntactic = 2
6182    }
6183    interface IncompleteCompletionsCache {
6184        get(): CompletionInfo | undefined;
6185        set(response: CompletionInfo): void;
6186        clear(): void;
6187    }
6188    interface LanguageServiceHost extends GetEffectiveTypeRootsHost, MinimalResolutionCacheHost {
6189        getCompilationSettings(): CompilerOptions;
6190        getNewLine?(): string;
6191        getProjectVersion?(): string;
6192        getScriptFileNames(): string[];
6193        getScriptKind?(fileName: string): ScriptKind;
6194        getScriptVersion(fileName: string): string;
6195        getScriptSnapshot(fileName: string): IScriptSnapshot | undefined;
6196        getProjectReferences?(): readonly ProjectReference[] | undefined;
6197        getLocalizedDiagnosticMessages?(): any;
6198        getCancellationToken?(): HostCancellationToken;
6199        getCurrentDirectory(): string;
6200        getDefaultLibFileName(options: CompilerOptions): string;
6201        log?(s: string): void;
6202        trace?(s: string): void;
6203        error?(s: string): void;
6204        useCaseSensitiveFileNames?(): boolean;
6205        readDirectory?(path: string, extensions?: readonly string[], exclude?: readonly string[], include?: readonly string[], depth?: number): string[];
6206        realpath?(path: string): string;
6207        readFile(path: string, encoding?: string): string | undefined;
6208        fileExists(path: string): boolean;
6209        getTypeRootsVersion?(): number;
6210        resolveModuleNames?(moduleNames: string[], containingFile: string, reusedNames: string[] | undefined, redirectedReference: ResolvedProjectReference | undefined, options: CompilerOptions, containingSourceFile?: SourceFile): (ResolvedModule | undefined)[];
6211        getResolvedModuleWithFailedLookupLocationsFromCache?(modulename: string, containingFile: string, resolutionMode?: ModuleKind.CommonJS | ModuleKind.ESNext): ResolvedModuleWithFailedLookupLocations | undefined;
6212        resolveTypeReferenceDirectives?(typeDirectiveNames: string[] | FileReference[], containingFile: string, redirectedReference: ResolvedProjectReference | undefined, options: CompilerOptions, containingFileMode?: SourceFile["impliedNodeFormat"] | undefined): (ResolvedTypeReferenceDirective | undefined)[];
6213        getDirectories?(directoryName: string): string[];
6214        /**
6215         * Gets a set of custom transformers to use during emit.
6216         */
6217        getCustomTransformers?(): CustomTransformers | undefined;
6218        isKnownTypesPackageName?(name: string): boolean;
6219        installPackage?(options: InstallPackageOptions): Promise<ApplyCodeActionCommandResult>;
6220        writeFile?(fileName: string, content: string): void;
6221        getParsedCommandLine?(fileName: string): ParsedCommandLine | undefined;
6222        getJsDocNodeCheckedConfig?(jsDocFileCheckInfo: FileCheckModuleInfo, symbolSourceFilePath: string): JsDocNodeCheckConfig;
6223        getJsDocNodeConditionCheckedResult?(jsDocFileCheckedInfo: FileCheckModuleInfo, jsDocs: JsDocTagInfo[]): ConditionCheckResult;
6224        getFileCheckedModuleInfo?(containFilePath: string): FileCheckModuleInfo;
6225        shouldCompletionSortCustom?: boolean;
6226        uiProps?: string[];
6227        clearProps?(): void;
6228    }
6229    type WithMetadata<T> = T & {
6230        metadata?: unknown;
6231    };
6232    enum SemanticClassificationFormat {
6233        Original = "original",
6234        TwentyTwenty = "2020"
6235    }
6236    interface LanguageService {
6237        /** This is used as a part of restarting the language service. */
6238        cleanupSemanticCache(): void;
6239        /**
6240         * Gets errors indicating invalid syntax in a file.
6241         *
6242         * In English, "this cdeo have, erorrs" is syntactically invalid because it has typos,
6243         * grammatical errors, and misplaced punctuation. Likewise, examples of syntax
6244         * errors in TypeScript are missing parentheses in an `if` statement, mismatched
6245         * curly braces, and using a reserved keyword as a variable name.
6246         *
6247         * These diagnostics are inexpensive to compute and don't require knowledge of
6248         * other files. Note that a non-empty result increases the likelihood of false positives
6249         * from `getSemanticDiagnostics`.
6250         *
6251         * While these represent the majority of syntax-related diagnostics, there are some
6252         * that require the type system, which will be present in `getSemanticDiagnostics`.
6253         *
6254         * @param fileName A path to the file you want syntactic diagnostics for
6255         */
6256        getSyntacticDiagnostics(fileName: string): DiagnosticWithLocation[];
6257        /**
6258         * Gets warnings or errors indicating type system issues in a given file.
6259         * Requesting semantic diagnostics may start up the type system and
6260         * run deferred work, so the first call may take longer than subsequent calls.
6261         *
6262         * Unlike the other get*Diagnostics functions, these diagnostics can potentially not
6263         * include a reference to a source file. Specifically, the first time this is called,
6264         * it will return global diagnostics with no associated location.
6265         *
6266         * To contrast the differences between semantic and syntactic diagnostics, consider the
6267         * sentence: "The sun is green." is syntactically correct; those are real English words with
6268         * correct sentence structure. However, it is semantically invalid, because it is not true.
6269         *
6270         * @param fileName A path to the file you want semantic diagnostics for
6271         */
6272        getSemanticDiagnostics(fileName: string): Diagnostic[];
6273        /**
6274         * Gets suggestion diagnostics for a specific file. These diagnostics tend to
6275         * proactively suggest refactors, as opposed to diagnostics that indicate
6276         * potentially incorrect runtime behavior.
6277         *
6278         * @param fileName A path to the file you want semantic diagnostics for
6279         */
6280        getSuggestionDiagnostics(fileName: string): DiagnosticWithLocation[];
6281        /**
6282         * Gets global diagnostics related to the program configuration and compiler options.
6283         */
6284        getCompilerOptionsDiagnostics(): Diagnostic[];
6285        /** @deprecated Use getEncodedSyntacticClassifications instead. */
6286        getSyntacticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[];
6287        getSyntacticClassifications(fileName: string, span: TextSpan, format: SemanticClassificationFormat): ClassifiedSpan[] | ClassifiedSpan2020[];
6288        /** @deprecated Use getEncodedSemanticClassifications instead. */
6289        getSemanticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[];
6290        getSemanticClassifications(fileName: string, span: TextSpan, format: SemanticClassificationFormat): ClassifiedSpan[] | ClassifiedSpan2020[];
6291        /** Encoded as triples of [start, length, ClassificationType]. */
6292        getEncodedSyntacticClassifications(fileName: string, span: TextSpan): Classifications;
6293        /**
6294         * Gets semantic highlights information for a particular file. Has two formats, an older
6295         * version used by VS and a format used by VS Code.
6296         *
6297         * @param fileName The path to the file
6298         * @param position A text span to return results within
6299         * @param format Which format to use, defaults to "original"
6300         * @returns a number array encoded as triples of [start, length, ClassificationType, ...].
6301         */
6302        getEncodedSemanticClassifications(fileName: string, span: TextSpan, format?: SemanticClassificationFormat): Classifications;
6303        /**
6304         * Gets completion entries at a particular position in a file.
6305         *
6306         * @param fileName The path to the file
6307         * @param position A zero-based index of the character where you want the entries
6308         * @param options An object describing how the request was triggered and what kinds
6309         * of code actions can be returned with the completions.
6310         * @param formattingSettings settings needed for calling formatting functions.
6311         */
6312        getCompletionsAtPosition(fileName: string, position: number, options: GetCompletionsAtPositionOptions | undefined, formattingSettings?: FormatCodeSettings): WithMetadata<CompletionInfo> | undefined;
6313        /**
6314         * Gets the extended details for a completion entry retrieved from `getCompletionsAtPosition`.
6315         *
6316         * @param fileName The path to the file
6317         * @param position A zero based index of the character where you want the entries
6318         * @param entryName The `name` from an existing completion which came from `getCompletionsAtPosition`
6319         * @param formatOptions How should code samples in the completions be formatted, can be undefined for backwards compatibility
6320         * @param source `source` property from the completion entry
6321         * @param preferences User settings, can be undefined for backwards compatibility
6322         * @param data `data` property from the completion entry
6323         */
6324        getCompletionEntryDetails(fileName: string, position: number, entryName: string, formatOptions: FormatCodeOptions | FormatCodeSettings | undefined, source: string | undefined, preferences: UserPreferences | undefined, data: CompletionEntryData | undefined): CompletionEntryDetails | undefined;
6325        getCompletionEntrySymbol(fileName: string, position: number, name: string, source: string | undefined): Symbol | undefined;
6326        /**
6327         * Gets semantic information about the identifier at a particular position in a
6328         * file. Quick info is what you typically see when you hover in an editor.
6329         *
6330         * @param fileName The path to the file
6331         * @param position A zero-based index of the character where you want the quick info
6332         */
6333        getQuickInfoAtPosition(fileName: string, position: number): QuickInfo | undefined;
6334        getNameOrDottedNameSpan(fileName: string, startPos: number, endPos: number): TextSpan | undefined;
6335        getBreakpointStatementAtPosition(fileName: string, position: number): TextSpan | undefined;
6336        getSignatureHelpItems(fileName: string, position: number, options: SignatureHelpItemsOptions | undefined): SignatureHelpItems | undefined;
6337        getRenameInfo(fileName: string, position: number, preferences: UserPreferences): RenameInfo;
6338        /** @deprecated Use the signature with `UserPreferences` instead. */
6339        getRenameInfo(fileName: string, position: number, options?: RenameInfoOptions): RenameInfo;
6340        findRenameLocations(fileName: string, position: number, findInStrings: boolean, findInComments: boolean, providePrefixAndSuffixTextForRename?: boolean): readonly RenameLocation[] | undefined;
6341        getSmartSelectionRange(fileName: string, position: number): SelectionRange;
6342        getDefinitionAtPosition(fileName: string, position: number): readonly DefinitionInfo[] | undefined;
6343        getDefinitionAndBoundSpan(fileName: string, position: number): DefinitionInfoAndBoundSpan | undefined;
6344        getTypeDefinitionAtPosition(fileName: string, position: number): readonly DefinitionInfo[] | undefined;
6345        getImplementationAtPosition(fileName: string, position: number): readonly ImplementationLocation[] | undefined;
6346        getReferencesAtPosition(fileName: string, position: number): ReferenceEntry[] | undefined;
6347        findReferences(fileName: string, position: number): ReferencedSymbol[] | undefined;
6348        getDocumentHighlights(fileName: string, position: number, filesToSearch: string[]): DocumentHighlights[] | undefined;
6349        getFileReferences(fileName: string): ReferenceEntry[];
6350        /** @deprecated */
6351        getOccurrencesAtPosition(fileName: string, position: number): readonly ReferenceEntry[] | undefined;
6352        getNavigateToItems(searchValue: string, maxResultCount?: number, fileName?: string, excludeDtsFiles?: boolean): NavigateToItem[];
6353        getNavigationBarItems(fileName: string): NavigationBarItem[];
6354        getNavigationTree(fileName: string): NavigationTree;
6355        prepareCallHierarchy(fileName: string, position: number): CallHierarchyItem | CallHierarchyItem[] | undefined;
6356        provideCallHierarchyIncomingCalls(fileName: string, position: number): CallHierarchyIncomingCall[];
6357        provideCallHierarchyOutgoingCalls(fileName: string, position: number): CallHierarchyOutgoingCall[];
6358        provideInlayHints(fileName: string, span: TextSpan, preferences: UserPreferences | undefined): InlayHint[];
6359        getOutliningSpans(fileName: string): OutliningSpan[];
6360        getTodoComments(fileName: string, descriptors: TodoCommentDescriptor[]): TodoComment[];
6361        getBraceMatchingAtPosition(fileName: string, position: number): TextSpan[];
6362        getIndentationAtPosition(fileName: string, position: number, options: EditorOptions | EditorSettings): number;
6363        getFormattingEditsForRange(fileName: string, start: number, end: number, options: FormatCodeOptions | FormatCodeSettings): TextChange[];
6364        getFormattingEditsForDocument(fileName: string, options: FormatCodeOptions | FormatCodeSettings): TextChange[];
6365        getFormattingEditsAfterKeystroke(fileName: string, position: number, key: string, options: FormatCodeOptions | FormatCodeSettings): TextChange[];
6366        getDocCommentTemplateAtPosition(fileName: string, position: number, options?: DocCommentTemplateOptions): TextInsertion | undefined;
6367        isValidBraceCompletionAtPosition(fileName: string, position: number, openingBrace: number): boolean;
6368        /**
6369         * This will return a defined result if the position is after the `>` of the opening tag, or somewhere in the text, of a JSXElement with no closing tag.
6370         * Editors should call this after `>` is typed.
6371         */
6372        getJsxClosingTagAtPosition(fileName: string, position: number): JsxClosingTagInfo | undefined;
6373        getSpanOfEnclosingComment(fileName: string, position: number, onlyMultiLine: boolean): TextSpan | undefined;
6374        toLineColumnOffset?(fileName: string, position: number): LineAndCharacter;
6375        getCodeFixesAtPosition(fileName: string, start: number, end: number, errorCodes: readonly number[], formatOptions: FormatCodeSettings, preferences: UserPreferences): readonly CodeFixAction[];
6376        getCombinedCodeFix(scope: CombinedCodeFixScope, fixId: {}, formatOptions: FormatCodeSettings, preferences: UserPreferences): CombinedCodeActions;
6377        applyCodeActionCommand(action: CodeActionCommand, formatSettings?: FormatCodeSettings): Promise<ApplyCodeActionCommandResult>;
6378        applyCodeActionCommand(action: CodeActionCommand[], formatSettings?: FormatCodeSettings): Promise<ApplyCodeActionCommandResult[]>;
6379        applyCodeActionCommand(action: CodeActionCommand | CodeActionCommand[], formatSettings?: FormatCodeSettings): Promise<ApplyCodeActionCommandResult | ApplyCodeActionCommandResult[]>;
6380        /** @deprecated `fileName` will be ignored */
6381        applyCodeActionCommand(fileName: string, action: CodeActionCommand): Promise<ApplyCodeActionCommandResult>;
6382        /** @deprecated `fileName` will be ignored */
6383        applyCodeActionCommand(fileName: string, action: CodeActionCommand[]): Promise<ApplyCodeActionCommandResult[]>;
6384        /** @deprecated `fileName` will be ignored */
6385        applyCodeActionCommand(fileName: string, action: CodeActionCommand | CodeActionCommand[]): Promise<ApplyCodeActionCommandResult | ApplyCodeActionCommandResult[]>;
6386        getApplicableRefactors(fileName: string, positionOrRange: number | TextRange, preferences: UserPreferences | undefined, triggerReason?: RefactorTriggerReason, kind?: string): ApplicableRefactorInfo[];
6387        getEditsForRefactor(fileName: string, formatOptions: FormatCodeSettings, positionOrRange: number | TextRange, refactorName: string, actionName: string, preferences: UserPreferences | undefined): RefactorEditInfo | undefined;
6388        organizeImports(args: OrganizeImportsArgs, formatOptions: FormatCodeSettings, preferences: UserPreferences | undefined): readonly FileTextChanges[];
6389        getEditsForFileRename(oldFilePath: string, newFilePath: string, formatOptions: FormatCodeSettings, preferences: UserPreferences | undefined): readonly FileTextChanges[];
6390        getEmitOutput(fileName: string, emitOnlyDtsFiles?: boolean, forceDtsEmit?: boolean): EmitOutput;
6391        getProgram(): Program | undefined;
6392        getBuilderProgram(): BuilderProgram | undefined;
6393        toggleLineComment(fileName: string, textRange: TextRange): TextChange[];
6394        toggleMultilineComment(fileName: string, textRange: TextRange): TextChange[];
6395        commentSelection(fileName: string, textRange: TextRange): TextChange[];
6396        uncommentSelection(fileName: string, textRange: TextRange): TextChange[];
6397        dispose(): void;
6398        updateRootFiles?(rootFiles: string[]): void;
6399        getProps?(): string[];
6400    }
6401    interface JsxClosingTagInfo {
6402        readonly newText: string;
6403    }
6404    interface CombinedCodeFixScope {
6405        type: "file";
6406        fileName: string;
6407    }
6408    enum OrganizeImportsMode {
6409        All = "All",
6410        SortAndCombine = "SortAndCombine",
6411        RemoveUnused = "RemoveUnused"
6412    }
6413    interface OrganizeImportsArgs extends CombinedCodeFixScope {
6414        /** @deprecated Use `mode` instead */
6415        skipDestructiveCodeActions?: boolean;
6416        mode?: OrganizeImportsMode;
6417    }
6418    type CompletionsTriggerCharacter = "." | '"' | "'" | "`" | "/" | "@" | "<" | "#" | " ";
6419    enum CompletionTriggerKind {
6420        /** Completion was triggered by typing an identifier, manual invocation (e.g Ctrl+Space) or via API. */
6421        Invoked = 1,
6422        /** Completion was triggered by a trigger character. */
6423        TriggerCharacter = 2,
6424        /** Completion was re-triggered as the current completion list is incomplete. */
6425        TriggerForIncompleteCompletions = 3
6426    }
6427    interface GetCompletionsAtPositionOptions extends UserPreferences {
6428        /**
6429         * If the editor is asking for completions because a certain character was typed
6430         * (as opposed to when the user explicitly requested them) this should be set.
6431         */
6432        triggerCharacter?: CompletionsTriggerCharacter;
6433        triggerKind?: CompletionTriggerKind;
6434        /** @deprecated Use includeCompletionsForModuleExports */
6435        includeExternalModuleExports?: boolean;
6436        /** @deprecated Use includeCompletionsWithInsertText */
6437        includeInsertTextCompletions?: boolean;
6438    }
6439    type SignatureHelpTriggerCharacter = "," | "(" | "<";
6440    type SignatureHelpRetriggerCharacter = SignatureHelpTriggerCharacter | ")";
6441    interface SignatureHelpItemsOptions {
6442        triggerReason?: SignatureHelpTriggerReason;
6443    }
6444    type SignatureHelpTriggerReason = SignatureHelpInvokedReason | SignatureHelpCharacterTypedReason | SignatureHelpRetriggeredReason;
6445    /**
6446     * Signals that the user manually requested signature help.
6447     * The language service will unconditionally attempt to provide a result.
6448     */
6449    interface SignatureHelpInvokedReason {
6450        kind: "invoked";
6451        triggerCharacter?: undefined;
6452    }
6453    /**
6454     * Signals that the signature help request came from a user typing a character.
6455     * Depending on the character and the syntactic context, the request may or may not be served a result.
6456     */
6457    interface SignatureHelpCharacterTypedReason {
6458        kind: "characterTyped";
6459        /**
6460         * Character that was responsible for triggering signature help.
6461         */
6462        triggerCharacter: SignatureHelpTriggerCharacter;
6463    }
6464    /**
6465     * Signals that this signature help request came from typing a character or moving the cursor.
6466     * This should only occur if a signature help session was already active and the editor needs to see if it should adjust.
6467     * The language service will unconditionally attempt to provide a result.
6468     * `triggerCharacter` can be `undefined` for a retrigger caused by a cursor move.
6469     */
6470    interface SignatureHelpRetriggeredReason {
6471        kind: "retrigger";
6472        /**
6473         * Character that was responsible for triggering signature help.
6474         */
6475        triggerCharacter?: SignatureHelpRetriggerCharacter;
6476    }
6477    interface ApplyCodeActionCommandResult {
6478        successMessage: string;
6479    }
6480    interface Classifications {
6481        spans: number[];
6482        endOfLineState: EndOfLineState;
6483    }
6484    interface ClassifiedSpan {
6485        textSpan: TextSpan;
6486        classificationType: ClassificationTypeNames;
6487    }
6488    interface ClassifiedSpan2020 {
6489        textSpan: TextSpan;
6490        classificationType: number;
6491    }
6492    /**
6493     * Navigation bar interface designed for visual studio's dual-column layout.
6494     * This does not form a proper tree.
6495     * The navbar is returned as a list of top-level items, each of which has a list of child items.
6496     * Child items always have an empty array for their `childItems`.
6497     */
6498    interface NavigationBarItem {
6499        text: string;
6500        kind: ScriptElementKind;
6501        kindModifiers: string;
6502        spans: TextSpan[];
6503        childItems: NavigationBarItem[];
6504        indent: number;
6505        bolded: boolean;
6506        grayed: boolean;
6507    }
6508    /**
6509     * Node in a tree of nested declarations in a file.
6510     * The top node is always a script or module node.
6511     */
6512    interface NavigationTree {
6513        /** Name of the declaration, or a short description, e.g. "<class>". */
6514        text: string;
6515        kind: ScriptElementKind;
6516        /** ScriptElementKindModifier separated by commas, e.g. "public,abstract" */
6517        kindModifiers: string;
6518        /**
6519         * Spans of the nodes that generated this declaration.
6520         * There will be more than one if this is the result of merging.
6521         */
6522        spans: TextSpan[];
6523        nameSpan: TextSpan | undefined;
6524        /** Present if non-empty */
6525        childItems?: NavigationTree[];
6526    }
6527    interface CallHierarchyItem {
6528        name: string;
6529        kind: ScriptElementKind;
6530        kindModifiers?: string;
6531        file: string;
6532        span: TextSpan;
6533        selectionSpan: TextSpan;
6534        containerName?: string;
6535    }
6536    interface CallHierarchyIncomingCall {
6537        from: CallHierarchyItem;
6538        fromSpans: TextSpan[];
6539    }
6540    interface CallHierarchyOutgoingCall {
6541        to: CallHierarchyItem;
6542        fromSpans: TextSpan[];
6543    }
6544    enum InlayHintKind {
6545        Type = "Type",
6546        Parameter = "Parameter",
6547        Enum = "Enum"
6548    }
6549    interface InlayHint {
6550        text: string;
6551        position: number;
6552        kind: InlayHintKind;
6553        whitespaceBefore?: boolean;
6554        whitespaceAfter?: boolean;
6555    }
6556    interface TodoCommentDescriptor {
6557        text: string;
6558        priority: number;
6559    }
6560    interface TodoComment {
6561        descriptor: TodoCommentDescriptor;
6562        message: string;
6563        position: number;
6564    }
6565    interface TextChange {
6566        span: TextSpan;
6567        newText: string;
6568    }
6569    interface FileTextChanges {
6570        fileName: string;
6571        textChanges: readonly TextChange[];
6572        isNewFile?: boolean;
6573    }
6574    interface CodeAction {
6575        /** Description of the code action to display in the UI of the editor */
6576        description: string;
6577        /** Text changes to apply to each file as part of the code action */
6578        changes: FileTextChanges[];
6579        /**
6580         * If the user accepts the code fix, the editor should send the action back in a `applyAction` request.
6581         * This allows the language service to have side effects (e.g. installing dependencies) upon a code fix.
6582         */
6583        commands?: CodeActionCommand[];
6584    }
6585    interface CodeFixAction extends CodeAction {
6586        /** Short name to identify the fix, for use by telemetry. */
6587        fixName: string;
6588        /**
6589         * If present, one may call 'getCombinedCodeFix' with this fixId.
6590         * This may be omitted to indicate that the code fix can't be applied in a group.
6591         */
6592        fixId?: {};
6593        fixAllDescription?: string;
6594    }
6595    interface CombinedCodeActions {
6596        changes: readonly FileTextChanges[];
6597        commands?: readonly CodeActionCommand[];
6598    }
6599    type CodeActionCommand = InstallPackageAction;
6600    interface InstallPackageAction {
6601    }
6602    /**
6603     * A set of one or more available refactoring actions, grouped under a parent refactoring.
6604     */
6605    interface ApplicableRefactorInfo {
6606        /**
6607         * The programmatic name of the refactoring
6608         */
6609        name: string;
6610        /**
6611         * A description of this refactoring category to show to the user.
6612         * If the refactoring gets inlined (see below), this text will not be visible.
6613         */
6614        description: string;
6615        /**
6616         * Inlineable refactorings can have their actions hoisted out to the top level
6617         * of a context menu. Non-inlineanable refactorings should always be shown inside
6618         * their parent grouping.
6619         *
6620         * If not specified, this value is assumed to be 'true'
6621         */
6622        inlineable?: boolean;
6623        actions: RefactorActionInfo[];
6624    }
6625    /**
6626     * Represents a single refactoring action - for example, the "Extract Method..." refactor might
6627     * offer several actions, each corresponding to a surround class or closure to extract into.
6628     */
6629    interface RefactorActionInfo {
6630        /**
6631         * The programmatic name of the refactoring action
6632         */
6633        name: string;
6634        /**
6635         * A description of this refactoring action to show to the user.
6636         * If the parent refactoring is inlined away, this will be the only text shown,
6637         * so this description should make sense by itself if the parent is inlineable=true
6638         */
6639        description: string;
6640        /**
6641         * A message to show to the user if the refactoring cannot be applied in
6642         * the current context.
6643         */
6644        notApplicableReason?: string;
6645        /**
6646         * The hierarchical dotted name of the refactor action.
6647         */
6648        kind?: string;
6649    }
6650    /**
6651     * A set of edits to make in response to a refactor action, plus an optional
6652     * location where renaming should be invoked from
6653     */
6654    interface RefactorEditInfo {
6655        edits: FileTextChanges[];
6656        renameFilename?: string;
6657        renameLocation?: number;
6658        commands?: CodeActionCommand[];
6659    }
6660    type RefactorTriggerReason = "implicit" | "invoked";
6661    interface TextInsertion {
6662        newText: string;
6663        /** The position in newText the caret should point to after the insertion. */
6664        caretOffset: number;
6665    }
6666    interface DocumentSpan {
6667        textSpan: TextSpan;
6668        fileName: string;
6669        /**
6670         * If the span represents a location that was remapped (e.g. via a .d.ts.map file),
6671         * then the original filename and span will be specified here
6672         */
6673        originalTextSpan?: TextSpan;
6674        originalFileName?: string;
6675        /**
6676         * If DocumentSpan.textSpan is the span for name of the declaration,
6677         * then this is the span for relevant declaration
6678         */
6679        contextSpan?: TextSpan;
6680        originalContextSpan?: TextSpan;
6681    }
6682    interface RenameLocation extends DocumentSpan {
6683        readonly prefixText?: string;
6684        readonly suffixText?: string;
6685    }
6686    interface ReferenceEntry extends DocumentSpan {
6687        isWriteAccess: boolean;
6688        isInString?: true;
6689    }
6690    interface ImplementationLocation extends DocumentSpan {
6691        kind: ScriptElementKind;
6692        displayParts: SymbolDisplayPart[];
6693    }
6694    enum HighlightSpanKind {
6695        none = "none",
6696        definition = "definition",
6697        reference = "reference",
6698        writtenReference = "writtenReference"
6699    }
6700    interface HighlightSpan {
6701        fileName?: string;
6702        isInString?: true;
6703        textSpan: TextSpan;
6704        contextSpan?: TextSpan;
6705        kind: HighlightSpanKind;
6706    }
6707    interface NavigateToItem {
6708        name: string;
6709        kind: ScriptElementKind;
6710        kindModifiers: string;
6711        matchKind: "exact" | "prefix" | "substring" | "camelCase";
6712        isCaseSensitive: boolean;
6713        fileName: string;
6714        textSpan: TextSpan;
6715        containerName: string;
6716        containerKind: ScriptElementKind;
6717    }
6718    enum IndentStyle {
6719        None = 0,
6720        Block = 1,
6721        Smart = 2
6722    }
6723    enum SemicolonPreference {
6724        Ignore = "ignore",
6725        Insert = "insert",
6726        Remove = "remove"
6727    }
6728    /** @deprecated - consider using EditorSettings instead */
6729    interface EditorOptions {
6730        BaseIndentSize?: number;
6731        IndentSize: number;
6732        TabSize: number;
6733        NewLineCharacter: string;
6734        ConvertTabsToSpaces: boolean;
6735        IndentStyle: IndentStyle;
6736    }
6737    interface EditorSettings {
6738        baseIndentSize?: number;
6739        indentSize?: number;
6740        tabSize?: number;
6741        newLineCharacter?: string;
6742        convertTabsToSpaces?: boolean;
6743        indentStyle?: IndentStyle;
6744        trimTrailingWhitespace?: boolean;
6745    }
6746    /** @deprecated - consider using FormatCodeSettings instead */
6747    interface FormatCodeOptions extends EditorOptions {
6748        InsertSpaceAfterCommaDelimiter: boolean;
6749        InsertSpaceAfterSemicolonInForStatements: boolean;
6750        InsertSpaceBeforeAndAfterBinaryOperators: boolean;
6751        InsertSpaceAfterConstructor?: boolean;
6752        InsertSpaceAfterKeywordsInControlFlowStatements: boolean;
6753        InsertSpaceAfterFunctionKeywordForAnonymousFunctions: boolean;
6754        InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: boolean;
6755        InsertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: boolean;
6756        InsertSpaceAfterOpeningAndBeforeClosingNonemptyBraces?: boolean;
6757        InsertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: boolean;
6758        InsertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces?: boolean;
6759        InsertSpaceAfterTypeAssertion?: boolean;
6760        InsertSpaceBeforeFunctionParenthesis?: boolean;
6761        PlaceOpenBraceOnNewLineForFunctions: boolean;
6762        PlaceOpenBraceOnNewLineForControlBlocks: boolean;
6763        insertSpaceBeforeTypeAnnotation?: boolean;
6764    }
6765    interface FormatCodeSettings extends EditorSettings {
6766        readonly insertSpaceAfterCommaDelimiter?: boolean;
6767        readonly insertSpaceAfterSemicolonInForStatements?: boolean;
6768        readonly insertSpaceBeforeAndAfterBinaryOperators?: boolean;
6769        readonly insertSpaceAfterConstructor?: boolean;
6770        readonly insertSpaceAfterKeywordsInControlFlowStatements?: boolean;
6771        readonly insertSpaceAfterFunctionKeywordForAnonymousFunctions?: boolean;
6772        readonly insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis?: boolean;
6773        readonly insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets?: boolean;
6774        readonly insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces?: boolean;
6775        readonly insertSpaceAfterOpeningAndBeforeClosingEmptyBraces?: boolean;
6776        readonly insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces?: boolean;
6777        readonly insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces?: boolean;
6778        readonly insertSpaceAfterTypeAssertion?: boolean;
6779        readonly insertSpaceBeforeFunctionParenthesis?: boolean;
6780        readonly placeOpenBraceOnNewLineForFunctions?: boolean;
6781        readonly placeOpenBraceOnNewLineForControlBlocks?: boolean;
6782        readonly insertSpaceBeforeTypeAnnotation?: boolean;
6783        readonly indentMultiLineObjectLiteralBeginningOnBlankLine?: boolean;
6784        readonly semicolons?: SemicolonPreference;
6785    }
6786    function getDefaultFormatCodeSettings(newLineCharacter?: string): FormatCodeSettings;
6787    interface DefinitionInfo extends DocumentSpan {
6788        kind: ScriptElementKind;
6789        name: string;
6790        containerKind: ScriptElementKind;
6791        containerName: string;
6792        unverified?: boolean;
6793    }
6794    interface DefinitionInfoAndBoundSpan {
6795        definitions?: readonly DefinitionInfo[];
6796        textSpan: TextSpan;
6797    }
6798    interface ReferencedSymbolDefinitionInfo extends DefinitionInfo {
6799        displayParts: SymbolDisplayPart[];
6800    }
6801    interface ReferencedSymbol {
6802        definition: ReferencedSymbolDefinitionInfo;
6803        references: ReferencedSymbolEntry[];
6804    }
6805    interface ReferencedSymbolEntry extends ReferenceEntry {
6806        isDefinition?: boolean;
6807    }
6808    enum SymbolDisplayPartKind {
6809        aliasName = 0,
6810        className = 1,
6811        enumName = 2,
6812        fieldName = 3,
6813        interfaceName = 4,
6814        keyword = 5,
6815        lineBreak = 6,
6816        numericLiteral = 7,
6817        stringLiteral = 8,
6818        localName = 9,
6819        methodName = 10,
6820        moduleName = 11,
6821        operator = 12,
6822        parameterName = 13,
6823        propertyName = 14,
6824        punctuation = 15,
6825        space = 16,
6826        text = 17,
6827        typeParameterName = 18,
6828        enumMemberName = 19,
6829        functionName = 20,
6830        regularExpressionLiteral = 21,
6831        link = 22,
6832        linkName = 23,
6833        linkText = 24
6834    }
6835    interface SymbolDisplayPart {
6836        text: string;
6837        kind: string;
6838    }
6839    interface JSDocLinkDisplayPart extends SymbolDisplayPart {
6840        target: DocumentSpan;
6841    }
6842    interface JSDocTagInfo {
6843        name: string;
6844        text?: SymbolDisplayPart[] | string;
6845        index?: number;
6846    }
6847    interface QuickInfo {
6848        kind: ScriptElementKind;
6849        kindModifiers: string;
6850        textSpan: TextSpan;
6851        displayParts?: SymbolDisplayPart[];
6852        documentation?: SymbolDisplayPart[];
6853        tags?: JSDocTagInfo[];
6854    }
6855    type RenameInfo = RenameInfoSuccess | RenameInfoFailure;
6856    interface RenameInfoSuccess {
6857        canRename: true;
6858        /**
6859         * File or directory to rename.
6860         * If set, `getEditsForFileRename` should be called instead of `findRenameLocations`.
6861         */
6862        fileToRename?: string;
6863        displayName: string;
6864        fullDisplayName: string;
6865        kind: ScriptElementKind;
6866        kindModifiers: string;
6867        triggerSpan: TextSpan;
6868    }
6869    interface RenameInfoFailure {
6870        canRename: false;
6871        localizedErrorMessage: string;
6872    }
6873    /**
6874     * @deprecated Use `UserPreferences` instead.
6875     */
6876    interface RenameInfoOptions {
6877        readonly allowRenameOfImportPath?: boolean;
6878    }
6879    interface DocCommentTemplateOptions {
6880        readonly generateReturnInDocTemplate?: boolean;
6881    }
6882    interface SignatureHelpParameter {
6883        name: string;
6884        documentation: SymbolDisplayPart[];
6885        displayParts: SymbolDisplayPart[];
6886        isOptional: boolean;
6887        isRest?: boolean;
6888    }
6889    interface SelectionRange {
6890        textSpan: TextSpan;
6891        parent?: SelectionRange;
6892    }
6893    /**
6894     * Represents a single signature to show in signature help.
6895     * The id is used for subsequent calls into the language service to ask questions about the
6896     * signature help item in the context of any documents that have been updated.  i.e. after
6897     * an edit has happened, while signature help is still active, the host can ask important
6898     * questions like 'what parameter is the user currently contained within?'.
6899     */
6900    interface SignatureHelpItem {
6901        isVariadic: boolean;
6902        prefixDisplayParts: SymbolDisplayPart[];
6903        suffixDisplayParts: SymbolDisplayPart[];
6904        separatorDisplayParts: SymbolDisplayPart[];
6905        parameters: SignatureHelpParameter[];
6906        documentation: SymbolDisplayPart[];
6907        tags: JSDocTagInfo[];
6908    }
6909    /**
6910     * Represents a set of signature help items, and the preferred item that should be selected.
6911     */
6912    interface SignatureHelpItems {
6913        items: SignatureHelpItem[];
6914        applicableSpan: TextSpan;
6915        selectedItemIndex: number;
6916        argumentIndex: number;
6917        argumentCount: number;
6918    }
6919    enum CompletionInfoFlags {
6920        None = 0,
6921        MayIncludeAutoImports = 1,
6922        IsImportStatementCompletion = 2,
6923        IsContinuation = 4,
6924        ResolvedModuleSpecifiers = 8,
6925        ResolvedModuleSpecifiersBeyondLimit = 16,
6926        MayIncludeMethodSnippets = 32
6927    }
6928    interface CompletionInfo {
6929        /** For performance telemetry. */
6930        flags?: CompletionInfoFlags;
6931        /** Not true for all global completions. This will be true if the enclosing scope matches a few syntax kinds. See `isSnippetScope`. */
6932        isGlobalCompletion: boolean;
6933        isMemberCompletion: boolean;
6934        /**
6935         * In the absence of `CompletionEntry["replacementSpan"]`, the editor may choose whether to use
6936         * this span or its default one. If `CompletionEntry["replacementSpan"]` is defined, that span
6937         * must be used to commit that completion entry.
6938         */
6939        optionalReplacementSpan?: TextSpan;
6940        /**
6941         * true when the current location also allows for a new identifier
6942         */
6943        isNewIdentifierLocation: boolean;
6944        /**
6945         * Indicates to client to continue requesting completions on subsequent keystrokes.
6946         */
6947        isIncomplete?: true;
6948        entries: CompletionEntry[];
6949    }
6950    interface CompletionEntryDataAutoImport {
6951        /**
6952         * The name of the property or export in the module's symbol table. Differs from the completion name
6953         * in the case of InternalSymbolName.ExportEquals and InternalSymbolName.Default.
6954         */
6955        exportName: string;
6956        moduleSpecifier?: string;
6957        /** The file name declaring the export's module symbol, if it was an external module */
6958        fileName?: string;
6959        /** The module name (with quotes stripped) of the export's module symbol, if it was an ambient module */
6960        ambientModuleName?: string;
6961        /** True if the export was found in the package.json AutoImportProvider */
6962        isPackageJsonImport?: true;
6963    }
6964    interface CompletionEntryDataUnresolved extends CompletionEntryDataAutoImport {
6965        /** The key in the `ExportMapCache` where the completion entry's `SymbolExportInfo[]` is found */
6966        exportMapKey: string;
6967    }
6968    interface CompletionEntryDataResolved extends CompletionEntryDataAutoImport {
6969        moduleSpecifier: string;
6970    }
6971    type CompletionEntryData = CompletionEntryDataUnresolved | CompletionEntryDataResolved;
6972    interface CompletionEntry {
6973        name: string;
6974        kind: ScriptElementKind;
6975        kindModifiers?: string;
6976        sortText: string;
6977        insertText?: string;
6978        isSnippet?: true;
6979        /**
6980         * An optional span that indicates the text to be replaced by this completion item.
6981         * If present, this span should be used instead of the default one.
6982         * It will be set if the required span differs from the one generated by the default replacement behavior.
6983         */
6984        replacementSpan?: TextSpan;
6985        hasAction?: true;
6986        source?: string;
6987        sourceDisplay?: SymbolDisplayPart[];
6988        labelDetails?: CompletionEntryLabelDetails;
6989        isRecommended?: true;
6990        isFromUncheckedFile?: true;
6991        isPackageJsonImport?: true;
6992        isImportStatementCompletion?: true;
6993        /**
6994         * A property to be sent back to TS Server in the CompletionDetailsRequest, along with `name`,
6995         * that allows TS Server to look up the symbol represented by the completion item, disambiguating
6996         * items with the same name. Currently only defined for auto-import completions, but the type is
6997         * `unknown` in the protocol, so it can be changed as needed to support other kinds of completions.
6998         * The presence of this property should generally not be used to assume that this completion entry
6999         * is an auto-import.
7000         */
7001        data?: CompletionEntryData;
7002        jsDoc?: JSDocTagInfo[];
7003        displayParts?: SymbolDisplayPart[];
7004    }
7005    interface CompletionEntryLabelDetails {
7006        detail?: string;
7007        description?: string;
7008    }
7009    interface CompletionEntryDetails {
7010        name: string;
7011        kind: ScriptElementKind;
7012        kindModifiers: string;
7013        displayParts: SymbolDisplayPart[];
7014        documentation?: SymbolDisplayPart[];
7015        tags?: JSDocTagInfo[];
7016        codeActions?: CodeAction[];
7017        /** @deprecated Use `sourceDisplay` instead. */
7018        source?: SymbolDisplayPart[];
7019        sourceDisplay?: SymbolDisplayPart[];
7020    }
7021    interface OutliningSpan {
7022        /** The span of the document to actually collapse. */
7023        textSpan: TextSpan;
7024        /** The span of the document to display when the user hovers over the collapsed span. */
7025        hintSpan: TextSpan;
7026        /** The text to display in the editor for the collapsed region. */
7027        bannerText: string;
7028        /**
7029         * Whether or not this region should be automatically collapsed when
7030         * the 'Collapse to Definitions' command is invoked.
7031         */
7032        autoCollapse: boolean;
7033        /**
7034         * Classification of the contents of the span
7035         */
7036        kind: OutliningSpanKind;
7037    }
7038    enum OutliningSpanKind {
7039        /** Single or multi-line comments */
7040        Comment = "comment",
7041        /** Sections marked by '// #region' and '// #endregion' comments */
7042        Region = "region",
7043        /** Declarations and expressions */
7044        Code = "code",
7045        /** Contiguous blocks of import declarations */
7046        Imports = "imports"
7047    }
7048    enum OutputFileType {
7049        JavaScript = 0,
7050        SourceMap = 1,
7051        Declaration = 2
7052    }
7053    enum EndOfLineState {
7054        None = 0,
7055        InMultiLineCommentTrivia = 1,
7056        InSingleQuoteStringLiteral = 2,
7057        InDoubleQuoteStringLiteral = 3,
7058        InTemplateHeadOrNoSubstitutionTemplate = 4,
7059        InTemplateMiddleOrTail = 5,
7060        InTemplateSubstitutionPosition = 6
7061    }
7062    enum TokenClass {
7063        Punctuation = 0,
7064        Keyword = 1,
7065        Operator = 2,
7066        Comment = 3,
7067        Whitespace = 4,
7068        Identifier = 5,
7069        NumberLiteral = 6,
7070        BigIntLiteral = 7,
7071        StringLiteral = 8,
7072        RegExpLiteral = 9
7073    }
7074    interface ClassificationResult {
7075        finalLexState: EndOfLineState;
7076        entries: ClassificationInfo[];
7077    }
7078    interface ClassificationInfo {
7079        length: number;
7080        classification: TokenClass;
7081    }
7082    interface Classifier {
7083        /**
7084         * Gives lexical classifications of tokens on a line without any syntactic context.
7085         * For instance, a token consisting of the text 'string' can be either an identifier
7086         * named 'string' or the keyword 'string', however, because this classifier is not aware,
7087         * it relies on certain heuristics to give acceptable results. For classifications where
7088         * speed trumps accuracy, this function is preferable; however, for true accuracy, the
7089         * syntactic classifier is ideal. In fact, in certain editing scenarios, combining the
7090         * lexical, syntactic, and semantic classifiers may issue the best user experience.
7091         *
7092         * @param text                      The text of a line to classify.
7093         * @param lexState                  The state of the lexical classifier at the end of the previous line.
7094         * @param syntacticClassifierAbsent Whether the client is *not* using a syntactic classifier.
7095         *                                  If there is no syntactic classifier (syntacticClassifierAbsent=true),
7096         *                                  certain heuristics may be used in its place; however, if there is a
7097         *                                  syntactic classifier (syntacticClassifierAbsent=false), certain
7098         *                                  classifications which may be incorrectly categorized will be given
7099         *                                  back as Identifiers in order to allow the syntactic classifier to
7100         *                                  subsume the classification.
7101         * @deprecated Use getLexicalClassifications instead.
7102         */
7103        getClassificationsForLine(text: string, lexState: EndOfLineState, syntacticClassifierAbsent: boolean): ClassificationResult;
7104        getEncodedLexicalClassifications(text: string, endOfLineState: EndOfLineState, syntacticClassifierAbsent: boolean): Classifications;
7105    }
7106    enum ScriptElementKind {
7107        unknown = "",
7108        warning = "warning",
7109        /** predefined type (void) or keyword (class) */
7110        keyword = "keyword",
7111        /** top level script node */
7112        scriptElement = "script",
7113        /** module foo {} */
7114        moduleElement = "module",
7115        /** class X {} */
7116        classElement = "class",
7117        /** var x = class X {} */
7118        localClassElement = "local class",
7119        /** struct X {} */
7120        structElement = "struct",
7121        /** interface Y {} */
7122        interfaceElement = "interface",
7123        /** type T = ... */
7124        typeElement = "type",
7125        /** enum E */
7126        enumElement = "enum",
7127        enumMemberElement = "enum member",
7128        /**
7129         * Inside module and script only
7130         * const v = ..
7131         */
7132        variableElement = "var",
7133        /** Inside function */
7134        localVariableElement = "local var",
7135        /**
7136         * Inside module and script only
7137         * function f() { }
7138         */
7139        functionElement = "function",
7140        /** Inside function */
7141        localFunctionElement = "local function",
7142        /** class X { [public|private]* foo() {} } */
7143        memberFunctionElement = "method",
7144        /** class X { [public|private]* [get|set] foo:number; } */
7145        memberGetAccessorElement = "getter",
7146        memberSetAccessorElement = "setter",
7147        /**
7148         * class X { [public|private]* foo:number; }
7149         * interface Y { foo:number; }
7150         */
7151        memberVariableElement = "property",
7152        /** class X { [public|private]* accessor foo: number; } */
7153        memberAccessorVariableElement = "accessor",
7154        /**
7155         * class X { constructor() { } }
7156         * class X { static { } }
7157         */
7158        constructorImplementationElement = "constructor",
7159        /** interface Y { ():number; } */
7160        callSignatureElement = "call",
7161        /** interface Y { []:number; } */
7162        indexSignatureElement = "index",
7163        /** interface Y { new():Y; } */
7164        constructSignatureElement = "construct",
7165        /** function foo(*Y*: string) */
7166        parameterElement = "parameter",
7167        typeParameterElement = "type parameter",
7168        primitiveType = "primitive type",
7169        label = "label",
7170        alias = "alias",
7171        constElement = "const",
7172        letElement = "let",
7173        directory = "directory",
7174        externalModuleName = "external module name",
7175        /**
7176         * <JsxTagName attribute1 attribute2={0} />
7177         * @deprecated
7178         */
7179        jsxAttribute = "JSX attribute",
7180        /** String literal */
7181        string = "string",
7182        /** Jsdoc @link: in `{@link C link text}`, the before and after text "{@link " and "}" */
7183        link = "link",
7184        /** Jsdoc @link: in `{@link C link text}`, the entity name "C" */
7185        linkName = "link name",
7186        /** Jsdoc @link: in `{@link C link text}`, the link text "link text" */
7187        linkText = "link text"
7188    }
7189    enum ScriptElementKindModifier {
7190        none = "",
7191        publicMemberModifier = "public",
7192        privateMemberModifier = "private",
7193        protectedMemberModifier = "protected",
7194        exportedModifier = "export",
7195        ambientModifier = "declare",
7196        staticModifier = "static",
7197        abstractModifier = "abstract",
7198        optionalModifier = "optional",
7199        deprecatedModifier = "deprecated",
7200        dtsModifier = ".d.ts",
7201        tsModifier = ".ts",
7202        tsxModifier = ".tsx",
7203        jsModifier = ".js",
7204        jsxModifier = ".jsx",
7205        jsonModifier = ".json",
7206        dmtsModifier = ".d.mts",
7207        mtsModifier = ".mts",
7208        mjsModifier = ".mjs",
7209        dctsModifier = ".d.cts",
7210        ctsModifier = ".cts",
7211        cjsModifier = ".cjs",
7212        etsModifier = ".ets",
7213        detsModifier = ".d.ets"
7214    }
7215    enum ClassificationTypeNames {
7216        comment = "comment",
7217        identifier = "identifier",
7218        keyword = "keyword",
7219        numericLiteral = "number",
7220        bigintLiteral = "bigint",
7221        operator = "operator",
7222        stringLiteral = "string",
7223        whiteSpace = "whitespace",
7224        text = "text",
7225        punctuation = "punctuation",
7226        className = "class name",
7227        enumName = "enum name",
7228        interfaceName = "interface name",
7229        moduleName = "module name",
7230        typeParameterName = "type parameter name",
7231        typeAliasName = "type alias name",
7232        parameterName = "parameter name",
7233        docCommentTagName = "doc comment tag name",
7234        jsxOpenTagName = "jsx open tag name",
7235        jsxCloseTagName = "jsx close tag name",
7236        jsxSelfClosingTagName = "jsx self closing tag name",
7237        jsxAttribute = "jsx attribute",
7238        jsxText = "jsx text",
7239        jsxAttributeStringLiteralValue = "jsx attribute string literal value"
7240    }
7241    enum ClassificationType {
7242        comment = 1,
7243        identifier = 2,
7244        keyword = 3,
7245        numericLiteral = 4,
7246        operator = 5,
7247        stringLiteral = 6,
7248        regularExpressionLiteral = 7,
7249        whiteSpace = 8,
7250        text = 9,
7251        punctuation = 10,
7252        className = 11,
7253        enumName = 12,
7254        interfaceName = 13,
7255        moduleName = 14,
7256        typeParameterName = 15,
7257        typeAliasName = 16,
7258        parameterName = 17,
7259        docCommentTagName = 18,
7260        jsxOpenTagName = 19,
7261        jsxCloseTagName = 20,
7262        jsxSelfClosingTagName = 21,
7263        jsxAttribute = 22,
7264        jsxText = 23,
7265        jsxAttributeStringLiteralValue = 24,
7266        bigintLiteral = 25
7267    }
7268    interface InlayHintsContext {
7269        file: SourceFile;
7270        program: Program;
7271        cancellationToken: CancellationToken;
7272        host: LanguageServiceHost;
7273        span: TextSpan;
7274        preferences: UserPreferences;
7275    }
7276}
7277declare namespace ts {
7278    /** The classifier is used for syntactic highlighting in editors via the TSServer */
7279    function createClassifier(): Classifier;
7280}
7281declare namespace ts {
7282    interface DocumentHighlights {
7283        fileName: string;
7284        highlightSpans: HighlightSpan[];
7285    }
7286}
7287declare namespace ts {
7288    /**
7289     * The document registry represents a store of SourceFile objects that can be shared between
7290     * multiple LanguageService instances. A LanguageService instance holds on the SourceFile (AST)
7291     * of files in the context.
7292     * SourceFile objects account for most of the memory usage by the language service. Sharing
7293     * the same DocumentRegistry instance between different instances of LanguageService allow
7294     * for more efficient memory utilization since all projects will share at least the library
7295     * file (lib.d.ts).
7296     *
7297     * A more advanced use of the document registry is to serialize sourceFile objects to disk
7298     * and re-hydrate them when needed.
7299     *
7300     * To create a default DocumentRegistry, use createDocumentRegistry to create one, and pass it
7301     * to all subsequent createLanguageService calls.
7302     */
7303    interface DocumentRegistry {
7304        /**
7305         * Request a stored SourceFile with a given fileName and compilationSettings.
7306         * The first call to acquire will call createLanguageServiceSourceFile to generate
7307         * the SourceFile if was not found in the registry.
7308         *
7309         * @param fileName The name of the file requested
7310         * @param compilationSettingsOrHost Some compilation settings like target affects the
7311         * shape of a the resulting SourceFile. This allows the DocumentRegistry to store
7312         * multiple copies of the same file for different compilation settings. A minimal
7313         * resolution cache is needed to fully define a source file's shape when
7314         * the compilation settings include `module: node16`+, so providing a cache host
7315         * object should be preferred. A common host is a language service `ConfiguredProject`.
7316         * @param scriptSnapshot Text of the file. Only used if the file was not found
7317         * in the registry and a new one was created.
7318         * @param version Current version of the file. Only used if the file was not found
7319         * in the registry and a new one was created.
7320         */
7321        acquireDocument(fileName: string, compilationSettingsOrHost: CompilerOptions | MinimalResolutionCacheHost, scriptSnapshot: IScriptSnapshot, version: string, scriptKind?: ScriptKind, sourceFileOptions?: CreateSourceFileOptions | ScriptTarget): SourceFile;
7322        acquireDocumentWithKey(fileName: string, path: Path, compilationSettingsOrHost: CompilerOptions | MinimalResolutionCacheHost, key: DocumentRegistryBucketKey, scriptSnapshot: IScriptSnapshot, version: string, scriptKind?: ScriptKind, sourceFileOptions?: CreateSourceFileOptions | ScriptTarget): SourceFile;
7323        /**
7324         * Request an updated version of an already existing SourceFile with a given fileName
7325         * and compilationSettings. The update will in-turn call updateLanguageServiceSourceFile
7326         * to get an updated SourceFile.
7327         *
7328         * @param fileName The name of the file requested
7329         * @param compilationSettingsOrHost Some compilation settings like target affects the
7330         * shape of a the resulting SourceFile. This allows the DocumentRegistry to store
7331         * multiple copies of the same file for different compilation settings. A minimal
7332         * resolution cache is needed to fully define a source file's shape when
7333         * the compilation settings include `module: node16`+, so providing a cache host
7334         * object should be preferred. A common host is a language service `ConfiguredProject`.
7335         * @param scriptSnapshot Text of the file.
7336         * @param version Current version of the file.
7337         */
7338        updateDocument(fileName: string, compilationSettingsOrHost: CompilerOptions | MinimalResolutionCacheHost, scriptSnapshot: IScriptSnapshot, version: string, scriptKind?: ScriptKind, sourceFileOptions?: CreateSourceFileOptions | ScriptTarget): SourceFile;
7339        updateDocumentWithKey(fileName: string, path: Path, compilationSettingsOrHost: CompilerOptions | MinimalResolutionCacheHost, key: DocumentRegistryBucketKey, scriptSnapshot: IScriptSnapshot, version: string, scriptKind?: ScriptKind, sourceFileOptions?: CreateSourceFileOptions | ScriptTarget): SourceFile;
7340        getKeyForCompilationSettings(settings: CompilerOptions): DocumentRegistryBucketKey;
7341        /**
7342         * Informs the DocumentRegistry that a file is not needed any longer.
7343         *
7344         * Note: It is not allowed to call release on a SourceFile that was not acquired from
7345         * this registry originally.
7346         *
7347         * @param fileName The name of the file to be released
7348         * @param compilationSettings The compilation settings used to acquire the file
7349         * @param scriptKind The script kind of the file to be released
7350         */
7351        /**@deprecated pass scriptKind and impliedNodeFormat for correctness */
7352        releaseDocument(fileName: string, compilationSettings: CompilerOptions, scriptKind?: ScriptKind): void;
7353        /**
7354         * Informs the DocumentRegistry that a file is not needed any longer.
7355         *
7356         * Note: It is not allowed to call release on a SourceFile that was not acquired from
7357         * this registry originally.
7358         *
7359         * @param fileName The name of the file to be released
7360         * @param compilationSettings The compilation settings used to acquire the file
7361         * @param scriptKind The script kind of the file to be released
7362         * @param impliedNodeFormat The implied source file format of the file to be released
7363         */
7364        releaseDocument(fileName: string, compilationSettings: CompilerOptions, scriptKind: ScriptKind, impliedNodeFormat: SourceFile["impliedNodeFormat"]): void;
7365        /**
7366         * @deprecated pass scriptKind for and impliedNodeFormat correctness */
7367        releaseDocumentWithKey(path: Path, key: DocumentRegistryBucketKey, scriptKind?: ScriptKind): void;
7368        releaseDocumentWithKey(path: Path, key: DocumentRegistryBucketKey, scriptKind: ScriptKind, impliedNodeFormat: SourceFile["impliedNodeFormat"]): void;
7369        reportStats(): string;
7370    }
7371    type DocumentRegistryBucketKey = string & {
7372        __bucketKey: any;
7373    };
7374    function createDocumentRegistry(useCaseSensitiveFileNames?: boolean, currentDirectory?: string): DocumentRegistry;
7375}
7376declare namespace ts {
7377    function preProcessFile(sourceText: string, readImportFiles?: boolean, detectJavaScriptImports?: boolean): PreProcessedFileInfo;
7378}
7379declare namespace ts {
7380    interface TranspileOptions {
7381        compilerOptions?: CompilerOptions;
7382        fileName?: string;
7383        reportDiagnostics?: boolean;
7384        moduleName?: string;
7385        renamedDependencies?: MapLike<string>;
7386        transformers?: CustomTransformers;
7387    }
7388    interface TranspileOutput {
7389        outputText: string;
7390        diagnostics?: Diagnostic[];
7391        sourceMapText?: string;
7392    }
7393    function transpileModule(input: string, transpileOptions: TranspileOptions): TranspileOutput;
7394    function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[], moduleName?: string): string;
7395}
7396declare namespace ts {
7397    /** The version of the language service API */
7398    const servicesVersion = "0.8";
7399    function toEditorSettings(options: EditorOptions | EditorSettings): EditorSettings;
7400    function displayPartsToString(displayParts: SymbolDisplayPart[] | undefined): string;
7401    function getDefaultCompilerOptions(): CompilerOptions;
7402    function getSupportedCodeFixes(): string[];
7403    function createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTargetOrOptions: ScriptTarget | CreateSourceFileOptions, version: string, setNodeParents: boolean, scriptKind?: ScriptKind, option?: CompilerOptions): SourceFile;
7404    function updateLanguageServiceSourceFile(sourceFile: SourceFile, scriptSnapshot: IScriptSnapshot, version: string, textChangeRange: TextChangeRange | undefined, aggressiveChecks?: boolean, option?: CompilerOptions): SourceFile;
7405    function createLanguageService(host: LanguageServiceHost, documentRegistry?: DocumentRegistry, syntaxOnlyOrLanguageServiceMode?: boolean | LanguageServiceMode): LanguageService;
7406    /**
7407     * Get the path of the default library files (lib.d.ts) as distributed with the typescript
7408     * node package.
7409     * The functionality is not supported if the ts module is consumed outside of a node module.
7410     */
7411    function getDefaultLibFilePath(options: CompilerOptions): string;
7412}
7413declare namespace ts {
7414    /**
7415     * Transform one or more nodes using the supplied transformers.
7416     * @param source A single `Node` or an array of `Node` objects.
7417     * @param transformers An array of `TransformerFactory` callbacks used to process the transformation.
7418     * @param compilerOptions Optional compiler options.
7419     */
7420    function transform<T extends Node>(source: T | T[], transformers: TransformerFactory<T>[], compilerOptions?: CompilerOptions): TransformationResult<T>;
7421}
7422declare namespace ts {
7423    /** @deprecated Use `factory.createNodeArray` or the factory supplied by your transformation context instead. */
7424    const createNodeArray: <T extends Node>(elements?: readonly T[] | undefined, hasTrailingComma?: boolean | undefined) => NodeArray<T>;
7425    /** @deprecated Use `factory.createNumericLiteral` or the factory supplied by your transformation context instead. */
7426    const createNumericLiteral: (value: string | number, numericLiteralFlags?: TokenFlags | undefined) => NumericLiteral;
7427    /** @deprecated Use `factory.createBigIntLiteral` or the factory supplied by your transformation context instead. */
7428    const createBigIntLiteral: (value: string | PseudoBigInt) => BigIntLiteral;
7429    /** @deprecated Use `factory.createStringLiteral` or the factory supplied by your transformation context instead. */
7430    const createStringLiteral: {
7431        (text: string, isSingleQuote?: boolean | undefined): StringLiteral;
7432        (text: string, isSingleQuote?: boolean | undefined, hasExtendedUnicodeEscape?: boolean | undefined): StringLiteral;
7433    };
7434    /** @deprecated Use `factory.createStringLiteralFromNode` or the factory supplied by your transformation context instead. */
7435    const createStringLiteralFromNode: (sourceNode: PrivateIdentifier | PropertyNameLiteral, isSingleQuote?: boolean | undefined) => StringLiteral;
7436    /** @deprecated Use `factory.createRegularExpressionLiteral` or the factory supplied by your transformation context instead. */
7437    const createRegularExpressionLiteral: (text: string) => RegularExpressionLiteral;
7438    /** @deprecated Use `factory.createLoopVariable` or the factory supplied by your transformation context instead. */
7439    const createLoopVariable: (reservedInNestedScopes?: boolean | undefined) => Identifier;
7440    /** @deprecated Use `factory.createUniqueName` or the factory supplied by your transformation context instead. */
7441    const createUniqueName: (text: string, flags?: GeneratedIdentifierFlags | undefined) => Identifier;
7442    /** @deprecated Use `factory.createPrivateIdentifier` or the factory supplied by your transformation context instead. */
7443    const createPrivateIdentifier: (text: string) => PrivateIdentifier;
7444    /** @deprecated Use `factory.createSuper` or the factory supplied by your transformation context instead. */
7445    const createSuper: () => SuperExpression;
7446    /** @deprecated Use `factory.createThis` or the factory supplied by your transformation context instead. */
7447    const createThis: () => ThisExpression;
7448    /** @deprecated Use `factory.createNull` or the factory supplied by your transformation context instead. */
7449    const createNull: () => NullLiteral;
7450    /** @deprecated Use `factory.createTrue` or the factory supplied by your transformation context instead. */
7451    const createTrue: () => TrueLiteral;
7452    /** @deprecated Use `factory.createFalse` or the factory supplied by your transformation context instead. */
7453    const createFalse: () => FalseLiteral;
7454    /** @deprecated Use `factory.createModifier` or the factory supplied by your transformation context instead. */
7455    const createModifier: <T extends ModifierSyntaxKind>(kind: T) => ModifierToken<T>;
7456    /** @deprecated Use `factory.createModifiersFromModifierFlags` or the factory supplied by your transformation context instead. */
7457    const createModifiersFromModifierFlags: (flags: ModifierFlags) => Modifier[] | undefined;
7458    /** @deprecated Use `factory.createQualifiedName` or the factory supplied by your transformation context instead. */
7459    const createQualifiedName: (left: EntityName, right: string | Identifier) => QualifiedName;
7460    /** @deprecated Use `factory.updateQualifiedName` or the factory supplied by your transformation context instead. */
7461    const updateQualifiedName: (node: QualifiedName, left: EntityName, right: Identifier) => QualifiedName;
7462    /** @deprecated Use `factory.createComputedPropertyName` or the factory supplied by your transformation context instead. */
7463    const createComputedPropertyName: (expression: Expression) => ComputedPropertyName;
7464    /** @deprecated Use `factory.updateComputedPropertyName` or the factory supplied by your transformation context instead. */
7465    const updateComputedPropertyName: (node: ComputedPropertyName, expression: Expression) => ComputedPropertyName;
7466    /** @deprecated Use `factory.createTypeParameterDeclaration` or the factory supplied by your transformation context instead. */
7467    const createTypeParameterDeclaration: {
7468        (modifiers: readonly Modifier[] | undefined, name: string | Identifier, constraint?: TypeNode | undefined, defaultType?: TypeNode | undefined): TypeParameterDeclaration;
7469        (name: string | Identifier, constraint?: TypeNode | undefined, defaultType?: TypeNode | undefined): TypeParameterDeclaration;
7470    };
7471    /** @deprecated Use `factory.updateTypeParameterDeclaration` or the factory supplied by your transformation context instead. */
7472    const updateTypeParameterDeclaration: {
7473        (node: TypeParameterDeclaration, modifiers: readonly Modifier[] | undefined, name: Identifier, constraint: TypeNode | undefined, defaultType: TypeNode | undefined): TypeParameterDeclaration;
7474        (node: TypeParameterDeclaration, name: Identifier, constraint: TypeNode | undefined, defaultType: TypeNode | undefined): TypeParameterDeclaration;
7475    };
7476    /** @deprecated Use `factory.createParameterDeclaration` or the factory supplied by your transformation context instead. */
7477    const createParameter: {
7478        (modifiers: readonly ModifierLike[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken?: QuestionToken | undefined, type?: TypeNode | undefined, initializer?: Expression | undefined): ParameterDeclaration;
7479        (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken?: QuestionToken | undefined, type?: TypeNode | undefined, initializer?: Expression | undefined): ParameterDeclaration;
7480    };
7481    /** @deprecated Use `factory.updateParameterDeclaration` or the factory supplied by your transformation context instead. */
7482    const updateParameter: {
7483        (node: ParameterDeclaration, modifiers: readonly ModifierLike[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): ParameterDeclaration;
7484        (node: ParameterDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): ParameterDeclaration;
7485    };
7486    /** @deprecated Use `factory.createDecorator` or the factory supplied by your transformation context instead. */
7487    const createDecorator: (expression: Expression) => Decorator;
7488    /** @deprecated Use `factory.updateDecorator` or the factory supplied by your transformation context instead. */
7489    const updateDecorator: (node: Decorator, expression: Expression) => Decorator;
7490    /** @deprecated Use `factory.createPropertyDeclaration` or the factory supplied by your transformation context instead. */
7491    const createProperty: {
7492        (modifiers: readonly ModifierLike[] | undefined, name: string | PropertyName, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertyDeclaration;
7493        (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertyDeclaration;
7494    };
7495    /** @deprecated Use `factory.updatePropertyDeclaration` or the factory supplied by your transformation context instead. */
7496    const updateProperty: {
7497        (node: PropertyDeclaration, modifiers: readonly ModifierLike[] | undefined, name: string | PropertyName, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertyDeclaration;
7498        (node: PropertyDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertyDeclaration;
7499    };
7500    /** @deprecated Use `factory.createMethodDeclaration` or the factory supplied by your transformation context instead. */
7501    const createMethod: {
7502        (modifiers: readonly ModifierLike[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | PropertyName, questionToken: QuestionToken | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): MethodDeclaration;
7503        (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | PropertyName, questionToken: QuestionToken | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): MethodDeclaration;
7504    };
7505    /** @deprecated Use `factory.updateMethodDeclaration` or the factory supplied by your transformation context instead. */
7506    const updateMethod: {
7507        (node: MethodDeclaration, modifiers: readonly ModifierLike[] | undefined, asteriskToken: AsteriskToken | undefined, name: PropertyName, questionToken: QuestionToken | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): MethodDeclaration;
7508        (node: MethodDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: PropertyName, questionToken: QuestionToken | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): MethodDeclaration;
7509    };
7510    /** @deprecated Use `factory.createConstructorDeclaration` or the factory supplied by your transformation context instead. */
7511    const createConstructor: {
7512        (modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], body: Block | undefined): ConstructorDeclaration;
7513        (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], body: Block | undefined): ConstructorDeclaration;
7514    };
7515    /** @deprecated Use `factory.updateConstructorDeclaration` or the factory supplied by your transformation context instead. */
7516    const updateConstructor: {
7517        (node: ConstructorDeclaration, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], body: Block | undefined): ConstructorDeclaration;
7518        (node: ConstructorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], body: Block | undefined): ConstructorDeclaration;
7519    };
7520    /** @deprecated Use `factory.createGetAccessorDeclaration` or the factory supplied by your transformation context instead. */
7521    const createGetAccessor: {
7522        (modifiers: readonly ModifierLike[] | undefined, name: string | PropertyName, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): GetAccessorDeclaration;
7523        (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): GetAccessorDeclaration;
7524    };
7525    /** @deprecated Use `factory.updateGetAccessorDeclaration` or the factory supplied by your transformation context instead. */
7526    const updateGetAccessor: {
7527        (node: GetAccessorDeclaration, modifiers: readonly ModifierLike[] | undefined, name: PropertyName, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): GetAccessorDeclaration;
7528        (node: GetAccessorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: PropertyName, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): GetAccessorDeclaration;
7529    };
7530    /** @deprecated Use `factory.createSetAccessorDeclaration` or the factory supplied by your transformation context instead. */
7531    const createSetAccessor: {
7532        (modifiers: readonly ModifierLike[] | undefined, name: string | PropertyName, parameters: readonly ParameterDeclaration[], body: Block | undefined): SetAccessorDeclaration;
7533        (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, parameters: readonly ParameterDeclaration[], body: Block | undefined): SetAccessorDeclaration;
7534    };
7535    /** @deprecated Use `factory.updateSetAccessorDeclaration` or the factory supplied by your transformation context instead. */
7536    const updateSetAccessor: {
7537        (node: SetAccessorDeclaration, modifiers: readonly ModifierLike[] | undefined, name: PropertyName, parameters: readonly ParameterDeclaration[], body: Block | undefined): SetAccessorDeclaration;
7538        (node: SetAccessorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: PropertyName, parameters: readonly ParameterDeclaration[], body: Block | undefined): SetAccessorDeclaration;
7539    };
7540    /** @deprecated Use `factory.createCallSignature` or the factory supplied by your transformation context instead. */
7541    const createCallSignature: (typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined) => CallSignatureDeclaration;
7542    /** @deprecated Use `factory.updateCallSignature` or the factory supplied by your transformation context instead. */
7543    const updateCallSignature: (node: CallSignatureDeclaration, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined) => CallSignatureDeclaration;
7544    /** @deprecated Use `factory.createConstructSignature` or the factory supplied by your transformation context instead. */
7545    const createConstructSignature: (typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined) => ConstructSignatureDeclaration;
7546    /** @deprecated Use `factory.updateConstructSignature` or the factory supplied by your transformation context instead. */
7547    const updateConstructSignature: (node: ConstructSignatureDeclaration, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined) => ConstructSignatureDeclaration;
7548    /** @deprecated Use `factory.updateIndexSignature` or the factory supplied by your transformation context instead. */
7549    const updateIndexSignature: {
7550        (node: IndexSignatureDeclaration, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration;
7551        (node: IndexSignatureDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration;
7552    };
7553    /** @deprecated Use `factory.createKeywordTypeNode` or the factory supplied by your transformation context instead. */
7554    const createKeywordTypeNode: <TKind extends KeywordTypeSyntaxKind>(kind: TKind) => KeywordTypeNode<TKind>;
7555    /** @deprecated Use `factory.createTypePredicateNode` or the factory supplied by your transformation context instead. */
7556    const createTypePredicateNodeWithModifier: (assertsModifier: AssertsKeyword | undefined, parameterName: string | Identifier | ThisTypeNode, type: TypeNode | undefined) => TypePredicateNode;
7557    /** @deprecated Use `factory.updateTypePredicateNode` or the factory supplied by your transformation context instead. */
7558    const updateTypePredicateNodeWithModifier: (node: TypePredicateNode, assertsModifier: AssertsKeyword | undefined, parameterName: Identifier | ThisTypeNode, type: TypeNode | undefined) => TypePredicateNode;
7559    /** @deprecated Use `factory.createTypeReferenceNode` or the factory supplied by your transformation context instead. */
7560    const createTypeReferenceNode: (typeName: string | EntityName, typeArguments?: readonly TypeNode[] | undefined) => TypeReferenceNode;
7561    /** @deprecated Use `factory.updateTypeReferenceNode` or the factory supplied by your transformation context instead. */
7562    const updateTypeReferenceNode: (node: TypeReferenceNode, typeName: EntityName, typeArguments: NodeArray<TypeNode> | undefined) => TypeReferenceNode;
7563    /** @deprecated Use `factory.createFunctionTypeNode` or the factory supplied by your transformation context instead. */
7564    const createFunctionTypeNode: (typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode) => FunctionTypeNode;
7565    /** @deprecated Use `factory.updateFunctionTypeNode` or the factory supplied by your transformation context instead. */
7566    const updateFunctionTypeNode: (node: FunctionTypeNode, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode) => FunctionTypeNode;
7567    /** @deprecated Use `factory.createConstructorTypeNode` or the factory supplied by your transformation context instead. */
7568    const createConstructorTypeNode: (typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode) => ConstructorTypeNode;
7569    /** @deprecated Use `factory.updateConstructorTypeNode` or the factory supplied by your transformation context instead. */
7570    const updateConstructorTypeNode: (node: ConstructorTypeNode, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode) => ConstructorTypeNode;
7571    /** @deprecated Use `factory.createTypeQueryNode` or the factory supplied by your transformation context instead. */
7572    const createTypeQueryNode: (exprName: EntityName, typeArguments?: readonly TypeNode[] | undefined) => TypeQueryNode;
7573    /** @deprecated Use `factory.updateTypeQueryNode` or the factory supplied by your transformation context instead. */
7574    const updateTypeQueryNode: (node: TypeQueryNode, exprName: EntityName, typeArguments?: readonly TypeNode[] | undefined) => TypeQueryNode;
7575    /** @deprecated Use `factory.createTypeLiteralNode` or the factory supplied by your transformation context instead. */
7576    const createTypeLiteralNode: (members: readonly TypeElement[] | undefined) => TypeLiteralNode;
7577    /** @deprecated Use `factory.updateTypeLiteralNode` or the factory supplied by your transformation context instead. */
7578    const updateTypeLiteralNode: (node: TypeLiteralNode, members: NodeArray<TypeElement>) => TypeLiteralNode;
7579    /** @deprecated Use `factory.createArrayTypeNode` or the factory supplied by your transformation context instead. */
7580    const createArrayTypeNode: (elementType: TypeNode) => ArrayTypeNode;
7581    /** @deprecated Use `factory.updateArrayTypeNode` or the factory supplied by your transformation context instead. */
7582    const updateArrayTypeNode: (node: ArrayTypeNode, elementType: TypeNode) => ArrayTypeNode;
7583    /** @deprecated Use `factory.createTupleTypeNode` or the factory supplied by your transformation context instead. */
7584    const createTupleTypeNode: (elements: readonly (TypeNode | NamedTupleMember)[]) => TupleTypeNode;
7585    /** @deprecated Use `factory.updateTupleTypeNode` or the factory supplied by your transformation context instead. */
7586    const updateTupleTypeNode: (node: TupleTypeNode, elements: readonly (TypeNode | NamedTupleMember)[]) => TupleTypeNode;
7587    /** @deprecated Use `factory.createOptionalTypeNode` or the factory supplied by your transformation context instead. */
7588    const createOptionalTypeNode: (type: TypeNode) => OptionalTypeNode;
7589    /** @deprecated Use `factory.updateOptionalTypeNode` or the factory supplied by your transformation context instead. */
7590    const updateOptionalTypeNode: (node: OptionalTypeNode, type: TypeNode) => OptionalTypeNode;
7591    /** @deprecated Use `factory.createRestTypeNode` or the factory supplied by your transformation context instead. */
7592    const createRestTypeNode: (type: TypeNode) => RestTypeNode;
7593    /** @deprecated Use `factory.updateRestTypeNode` or the factory supplied by your transformation context instead. */
7594    const updateRestTypeNode: (node: RestTypeNode, type: TypeNode) => RestTypeNode;
7595    /** @deprecated Use `factory.createUnionTypeNode` or the factory supplied by your transformation context instead. */
7596    const createUnionTypeNode: (types: readonly TypeNode[]) => UnionTypeNode;
7597    /** @deprecated Use `factory.updateUnionTypeNode` or the factory supplied by your transformation context instead. */
7598    const updateUnionTypeNode: (node: UnionTypeNode, types: NodeArray<TypeNode>) => UnionTypeNode;
7599    /** @deprecated Use `factory.createIntersectionTypeNode` or the factory supplied by your transformation context instead. */
7600    const createIntersectionTypeNode: (types: readonly TypeNode[]) => IntersectionTypeNode;
7601    /** @deprecated Use `factory.updateIntersectionTypeNode` or the factory supplied by your transformation context instead. */
7602    const updateIntersectionTypeNode: (node: IntersectionTypeNode, types: NodeArray<TypeNode>) => IntersectionTypeNode;
7603    /** @deprecated Use `factory.createConditionalTypeNode` or the factory supplied by your transformation context instead. */
7604    const createConditionalTypeNode: (checkType: TypeNode, extendsType: TypeNode, trueType: TypeNode, falseType: TypeNode) => ConditionalTypeNode;
7605    /** @deprecated Use `factory.updateConditionalTypeNode` or the factory supplied by your transformation context instead. */
7606    const updateConditionalTypeNode: (node: ConditionalTypeNode, checkType: TypeNode, extendsType: TypeNode, trueType: TypeNode, falseType: TypeNode) => ConditionalTypeNode;
7607    /** @deprecated Use `factory.createInferTypeNode` or the factory supplied by your transformation context instead. */
7608    const createInferTypeNode: (typeParameter: TypeParameterDeclaration) => InferTypeNode;
7609    /** @deprecated Use `factory.updateInferTypeNode` or the factory supplied by your transformation context instead. */
7610    const updateInferTypeNode: (node: InferTypeNode, typeParameter: TypeParameterDeclaration) => InferTypeNode;
7611    /** @deprecated Use `factory.createImportTypeNode` or the factory supplied by your transformation context instead. */
7612    const createImportTypeNode: {
7613        (argument: TypeNode, assertions?: ImportTypeAssertionContainer | undefined, qualifier?: EntityName | undefined, typeArguments?: readonly TypeNode[] | undefined, isTypeOf?: boolean | undefined): ImportTypeNode;
7614        (argument: TypeNode, assertions?: ImportTypeAssertionContainer | undefined, qualifier?: EntityName | undefined, typeArguments?: readonly TypeNode[] | undefined, isTypeOf?: boolean | undefined): ImportTypeNode;
7615        (argument: TypeNode, qualifier?: EntityName | undefined, typeArguments?: readonly TypeNode[] | undefined, isTypeOf?: boolean | undefined): ImportTypeNode;
7616    };
7617    /** @deprecated Use `factory.updateImportTypeNode` or the factory supplied by your transformation context instead. */
7618    const updateImportTypeNode: {
7619        (node: ImportTypeNode, argument: TypeNode, assertions: ImportTypeAssertionContainer | undefined, qualifier: EntityName | undefined, typeArguments: readonly TypeNode[] | undefined, isTypeOf?: boolean | undefined): ImportTypeNode;
7620        (node: ImportTypeNode, argument: TypeNode, qualifier: EntityName | undefined, typeArguments: readonly TypeNode[] | undefined, isTypeOf?: boolean | undefined): ImportTypeNode;
7621    };
7622    /** @deprecated Use `factory.createParenthesizedType` or the factory supplied by your transformation context instead. */
7623    const createParenthesizedType: (type: TypeNode) => ParenthesizedTypeNode;
7624    /** @deprecated Use `factory.updateParenthesizedType` or the factory supplied by your transformation context instead. */
7625    const updateParenthesizedType: (node: ParenthesizedTypeNode, type: TypeNode) => ParenthesizedTypeNode;
7626    /** @deprecated Use `factory.createThisTypeNode` or the factory supplied by your transformation context instead. */
7627    const createThisTypeNode: () => ThisTypeNode;
7628    /** @deprecated Use `factory.updateTypeOperatorNode` or the factory supplied by your transformation context instead. */
7629    const updateTypeOperatorNode: (node: TypeOperatorNode, type: TypeNode) => TypeOperatorNode;
7630    /** @deprecated Use `factory.createIndexedAccessTypeNode` or the factory supplied by your transformation context instead. */
7631    const createIndexedAccessTypeNode: (objectType: TypeNode, indexType: TypeNode) => IndexedAccessTypeNode;
7632    /** @deprecated Use `factory.updateIndexedAccessTypeNode` or the factory supplied by your transformation context instead. */
7633    const updateIndexedAccessTypeNode: (node: IndexedAccessTypeNode, objectType: TypeNode, indexType: TypeNode) => IndexedAccessTypeNode;
7634    /** @deprecated Use `factory.createMappedTypeNode` or the factory supplied by your transformation context instead. */
7635    const createMappedTypeNode: (readonlyToken: ReadonlyKeyword | PlusToken | MinusToken | undefined, typeParameter: TypeParameterDeclaration, nameType: TypeNode | undefined, questionToken: QuestionToken | PlusToken | MinusToken | undefined, type: TypeNode | undefined, members: NodeArray<TypeElement> | undefined) => MappedTypeNode;
7636    /** @deprecated Use `factory.updateMappedTypeNode` or the factory supplied by your transformation context instead. */
7637    const updateMappedTypeNode: (node: MappedTypeNode, readonlyToken: ReadonlyKeyword | PlusToken | MinusToken | undefined, typeParameter: TypeParameterDeclaration, nameType: TypeNode | undefined, questionToken: QuestionToken | PlusToken | MinusToken | undefined, type: TypeNode | undefined, members: NodeArray<TypeElement> | undefined) => MappedTypeNode;
7638    /** @deprecated Use `factory.createLiteralTypeNode` or the factory supplied by your transformation context instead. */
7639    const createLiteralTypeNode: (literal: LiteralExpression | BooleanLiteral | PrefixUnaryExpression | NullLiteral) => LiteralTypeNode;
7640    /** @deprecated Use `factory.updateLiteralTypeNode` or the factory supplied by your transformation context instead. */
7641    const updateLiteralTypeNode: (node: LiteralTypeNode, literal: LiteralExpression | BooleanLiteral | PrefixUnaryExpression | NullLiteral) => LiteralTypeNode;
7642    /** @deprecated Use `factory.createObjectBindingPattern` or the factory supplied by your transformation context instead. */
7643    const createObjectBindingPattern: (elements: readonly BindingElement[]) => ObjectBindingPattern;
7644    /** @deprecated Use `factory.updateObjectBindingPattern` or the factory supplied by your transformation context instead. */
7645    const updateObjectBindingPattern: (node: ObjectBindingPattern, elements: readonly BindingElement[]) => ObjectBindingPattern;
7646    /** @deprecated Use `factory.createArrayBindingPattern` or the factory supplied by your transformation context instead. */
7647    const createArrayBindingPattern: (elements: readonly ArrayBindingElement[]) => ArrayBindingPattern;
7648    /** @deprecated Use `factory.updateArrayBindingPattern` or the factory supplied by your transformation context instead. */
7649    const updateArrayBindingPattern: (node: ArrayBindingPattern, elements: readonly ArrayBindingElement[]) => ArrayBindingPattern;
7650    /** @deprecated Use `factory.createBindingElement` or the factory supplied by your transformation context instead. */
7651    const createBindingElement: (dotDotDotToken: DotDotDotToken | undefined, propertyName: string | PropertyName | undefined, name: string | BindingName, initializer?: Expression | undefined) => BindingElement;
7652    /** @deprecated Use `factory.updateBindingElement` or the factory supplied by your transformation context instead. */
7653    const updateBindingElement: (node: BindingElement, dotDotDotToken: DotDotDotToken | undefined, propertyName: PropertyName | undefined, name: BindingName, initializer: Expression | undefined) => BindingElement;
7654    /** @deprecated Use `factory.createArrayLiteralExpression` or the factory supplied by your transformation context instead. */
7655    const createArrayLiteral: (elements?: readonly Expression[] | undefined, multiLine?: boolean | undefined) => ArrayLiteralExpression;
7656    /** @deprecated Use `factory.updateArrayLiteralExpression` or the factory supplied by your transformation context instead. */
7657    const updateArrayLiteral: (node: ArrayLiteralExpression, elements: readonly Expression[]) => ArrayLiteralExpression;
7658    /** @deprecated Use `factory.createObjectLiteralExpression` or the factory supplied by your transformation context instead. */
7659    const createObjectLiteral: (properties?: readonly ObjectLiteralElementLike[] | undefined, multiLine?: boolean | undefined) => ObjectLiteralExpression;
7660    /** @deprecated Use `factory.updateObjectLiteralExpression` or the factory supplied by your transformation context instead. */
7661    const updateObjectLiteral: (node: ObjectLiteralExpression, properties: readonly ObjectLiteralElementLike[]) => ObjectLiteralExpression;
7662    /** @deprecated Use `factory.createPropertyAccessExpression` or the factory supplied by your transformation context instead. */
7663    const createPropertyAccess: (expression: Expression, name: string | MemberName) => PropertyAccessExpression;
7664    /** @deprecated Use `factory.updatePropertyAccessExpression` or the factory supplied by your transformation context instead. */
7665    const updatePropertyAccess: (node: PropertyAccessExpression, expression: Expression, name: MemberName) => PropertyAccessExpression;
7666    /** @deprecated Use `factory.createPropertyAccessChain` or the factory supplied by your transformation context instead. */
7667    const createPropertyAccessChain: (expression: Expression, questionDotToken: QuestionDotToken | undefined, name: string | MemberName) => PropertyAccessChain;
7668    /** @deprecated Use `factory.updatePropertyAccessChain` or the factory supplied by your transformation context instead. */
7669    const updatePropertyAccessChain: (node: PropertyAccessChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, name: MemberName) => PropertyAccessChain;
7670    /** @deprecated Use `factory.createElementAccessExpression` or the factory supplied by your transformation context instead. */
7671    const createElementAccess: (expression: Expression, index: number | Expression) => ElementAccessExpression;
7672    /** @deprecated Use `factory.updateElementAccessExpression` or the factory supplied by your transformation context instead. */
7673    const updateElementAccess: (node: ElementAccessExpression, expression: Expression, argumentExpression: Expression) => ElementAccessExpression;
7674    /** @deprecated Use `factory.createElementAccessChain` or the factory supplied by your transformation context instead. */
7675    const createElementAccessChain: (expression: Expression, questionDotToken: QuestionDotToken | undefined, index: number | Expression) => ElementAccessChain;
7676    /** @deprecated Use `factory.updateElementAccessChain` or the factory supplied by your transformation context instead. */
7677    const updateElementAccessChain: (node: ElementAccessChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, argumentExpression: Expression) => ElementAccessChain;
7678    /** @deprecated Use `factory.createCallExpression` or the factory supplied by your transformation context instead. */
7679    const createCall: (expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined) => CallExpression;
7680    /** @deprecated Use `factory.updateCallExpression` or the factory supplied by your transformation context instead. */
7681    const updateCall: (node: CallExpression, expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[]) => CallExpression;
7682    /** @deprecated Use `factory.createCallChain` or the factory supplied by your transformation context instead. */
7683    const createCallChain: (expression: Expression, questionDotToken: QuestionDotToken | undefined, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined) => CallChain;
7684    /** @deprecated Use `factory.updateCallChain` or the factory supplied by your transformation context instead. */
7685    const updateCallChain: (node: CallChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[]) => CallChain;
7686    /** @deprecated Use `factory.createNewExpression` or the factory supplied by your transformation context instead. */
7687    const createNew: (expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined) => NewExpression;
7688    /** @deprecated Use `factory.updateNewExpression` or the factory supplied by your transformation context instead. */
7689    const updateNew: (node: NewExpression, expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined) => NewExpression;
7690    /** @deprecated Use `factory.createTypeAssertion` or the factory supplied by your transformation context instead. */
7691    const createTypeAssertion: (type: TypeNode, expression: Expression) => TypeAssertion;
7692    /** @deprecated Use `factory.updateTypeAssertion` or the factory supplied by your transformation context instead. */
7693    const updateTypeAssertion: (node: TypeAssertion, type: TypeNode, expression: Expression) => TypeAssertion;
7694    /** @deprecated Use `factory.createParenthesizedExpression` or the factory supplied by your transformation context instead. */
7695    const createParen: (expression: Expression) => ParenthesizedExpression;
7696    /** @deprecated Use `factory.updateParenthesizedExpression` or the factory supplied by your transformation context instead. */
7697    const updateParen: (node: ParenthesizedExpression, expression: Expression) => ParenthesizedExpression;
7698    /** @deprecated Use `factory.createFunctionExpression` or the factory supplied by your transformation context instead. */
7699    const createFunctionExpression: (modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[] | undefined, type: TypeNode | undefined, body: Block) => FunctionExpression;
7700    /** @deprecated Use `factory.updateFunctionExpression` or the factory supplied by your transformation context instead. */
7701    const updateFunctionExpression: (node: FunctionExpression, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block) => FunctionExpression;
7702    /** @deprecated Use `factory.createDeleteExpression` or the factory supplied by your transformation context instead. */
7703    const createDelete: (expression: Expression) => DeleteExpression;
7704    /** @deprecated Use `factory.updateDeleteExpression` or the factory supplied by your transformation context instead. */
7705    const updateDelete: (node: DeleteExpression, expression: Expression) => DeleteExpression;
7706    /** @deprecated Use `factory.createTypeOfExpression` or the factory supplied by your transformation context instead. */
7707    const createTypeOf: (expression: Expression) => TypeOfExpression;
7708    /** @deprecated Use `factory.updateTypeOfExpression` or the factory supplied by your transformation context instead. */
7709    const updateTypeOf: (node: TypeOfExpression, expression: Expression) => TypeOfExpression;
7710    /** @deprecated Use `factory.createVoidExpression` or the factory supplied by your transformation context instead. */
7711    const createVoid: (expression: Expression) => VoidExpression;
7712    /** @deprecated Use `factory.updateVoidExpression` or the factory supplied by your transformation context instead. */
7713    const updateVoid: (node: VoidExpression, expression: Expression) => VoidExpression;
7714    /** @deprecated Use `factory.createAwaitExpression` or the factory supplied by your transformation context instead. */
7715    const createAwait: (expression: Expression) => AwaitExpression;
7716    /** @deprecated Use `factory.updateAwaitExpression` or the factory supplied by your transformation context instead. */
7717    const updateAwait: (node: AwaitExpression, expression: Expression) => AwaitExpression;
7718    /** @deprecated Use `factory.createPrefixExpression` or the factory supplied by your transformation context instead. */
7719    const createPrefix: (operator: PrefixUnaryOperator, operand: Expression) => PrefixUnaryExpression;
7720    /** @deprecated Use `factory.updatePrefixExpression` or the factory supplied by your transformation context instead. */
7721    const updatePrefix: (node: PrefixUnaryExpression, operand: Expression) => PrefixUnaryExpression;
7722    /** @deprecated Use `factory.createPostfixUnaryExpression` or the factory supplied by your transformation context instead. */
7723    const createPostfix: (operand: Expression, operator: PostfixUnaryOperator) => PostfixUnaryExpression;
7724    /** @deprecated Use `factory.updatePostfixUnaryExpression` or the factory supplied by your transformation context instead. */
7725    const updatePostfix: (node: PostfixUnaryExpression, operand: Expression) => PostfixUnaryExpression;
7726    /** @deprecated Use `factory.createBinaryExpression` or the factory supplied by your transformation context instead. */
7727    const createBinary: (left: Expression, operator: BinaryOperator | BinaryOperatorToken, right: Expression) => BinaryExpression;
7728    /** @deprecated Use `factory.updateConditionalExpression` or the factory supplied by your transformation context instead. */
7729    const updateConditional: (node: ConditionalExpression, condition: Expression, questionToken: QuestionToken, whenTrue: Expression, colonToken: ColonToken, whenFalse: Expression) => ConditionalExpression;
7730    /** @deprecated Use `factory.createTemplateExpression` or the factory supplied by your transformation context instead. */
7731    const createTemplateExpression: (head: TemplateHead, templateSpans: readonly TemplateSpan[]) => TemplateExpression;
7732    /** @deprecated Use `factory.updateTemplateExpression` or the factory supplied by your transformation context instead. */
7733    const updateTemplateExpression: (node: TemplateExpression, head: TemplateHead, templateSpans: readonly TemplateSpan[]) => TemplateExpression;
7734    /** @deprecated Use `factory.createTemplateHead` or the factory supplied by your transformation context instead. */
7735    const createTemplateHead: {
7736        (text: string, rawText?: string | undefined, templateFlags?: TokenFlags | undefined): TemplateHead;
7737        (text: string | undefined, rawText: string, templateFlags?: TokenFlags | undefined): TemplateHead;
7738    };
7739    /** @deprecated Use `factory.createTemplateMiddle` or the factory supplied by your transformation context instead. */
7740    const createTemplateMiddle: {
7741        (text: string, rawText?: string | undefined, templateFlags?: TokenFlags | undefined): TemplateMiddle;
7742        (text: string | undefined, rawText: string, templateFlags?: TokenFlags | undefined): TemplateMiddle;
7743    };
7744    /** @deprecated Use `factory.createTemplateTail` or the factory supplied by your transformation context instead. */
7745    const createTemplateTail: {
7746        (text: string, rawText?: string | undefined, templateFlags?: TokenFlags | undefined): TemplateTail;
7747        (text: string | undefined, rawText: string, templateFlags?: TokenFlags | undefined): TemplateTail;
7748    };
7749    /** @deprecated Use `factory.createNoSubstitutionTemplateLiteral` or the factory supplied by your transformation context instead. */
7750    const createNoSubstitutionTemplateLiteral: {
7751        (text: string, rawText?: string | undefined): NoSubstitutionTemplateLiteral;
7752        (text: string | undefined, rawText: string): NoSubstitutionTemplateLiteral;
7753    };
7754    /** @deprecated Use `factory.updateYieldExpression` or the factory supplied by your transformation context instead. */
7755    const updateYield: (node: YieldExpression, asteriskToken: AsteriskToken | undefined, expression: Expression | undefined) => YieldExpression;
7756    /** @deprecated Use `factory.createSpreadExpression` or the factory supplied by your transformation context instead. */
7757    const createSpread: (expression: Expression) => SpreadElement;
7758    /** @deprecated Use `factory.updateSpreadExpression` or the factory supplied by your transformation context instead. */
7759    const updateSpread: (node: SpreadElement, expression: Expression) => SpreadElement;
7760    /** @deprecated Use `factory.createOmittedExpression` or the factory supplied by your transformation context instead. */
7761    const createOmittedExpression: () => OmittedExpression;
7762    /** @deprecated Use `factory.createAsExpression` or the factory supplied by your transformation context instead. */
7763    const createAsExpression: (expression: Expression, type: TypeNode) => AsExpression;
7764    /** @deprecated Use `factory.updateAsExpression` or the factory supplied by your transformation context instead. */
7765    const updateAsExpression: (node: AsExpression, expression: Expression, type: TypeNode) => AsExpression;
7766    /** @deprecated Use `factory.createNonNullExpression` or the factory supplied by your transformation context instead. */
7767    const createNonNullExpression: (expression: Expression) => NonNullExpression;
7768    /** @deprecated Use `factory.updateNonNullExpression` or the factory supplied by your transformation context instead. */
7769    const updateNonNullExpression: (node: NonNullExpression, expression: Expression) => NonNullExpression;
7770    /** @deprecated Use `factory.createNonNullChain` or the factory supplied by your transformation context instead. */
7771    const createNonNullChain: (expression: Expression) => NonNullChain;
7772    /** @deprecated Use `factory.updateNonNullChain` or the factory supplied by your transformation context instead. */
7773    const updateNonNullChain: (node: NonNullChain, expression: Expression) => NonNullChain;
7774    /** @deprecated Use `factory.createMetaProperty` or the factory supplied by your transformation context instead. */
7775    const createMetaProperty: (keywordToken: SyntaxKind.ImportKeyword | SyntaxKind.NewKeyword, name: Identifier) => MetaProperty;
7776    /** @deprecated Use `factory.updateMetaProperty` or the factory supplied by your transformation context instead. */
7777    const updateMetaProperty: (node: MetaProperty, name: Identifier) => MetaProperty;
7778    /** @deprecated Use `factory.createTemplateSpan` or the factory supplied by your transformation context instead. */
7779    const createTemplateSpan: (expression: Expression, literal: TemplateMiddle | TemplateTail) => TemplateSpan;
7780    /** @deprecated Use `factory.updateTemplateSpan` or the factory supplied by your transformation context instead. */
7781    const updateTemplateSpan: (node: TemplateSpan, expression: Expression, literal: TemplateMiddle | TemplateTail) => TemplateSpan;
7782    /** @deprecated Use `factory.createSemicolonClassElement` or the factory supplied by your transformation context instead. */
7783    const createSemicolonClassElement: () => SemicolonClassElement;
7784    /** @deprecated Use `factory.createBlock` or the factory supplied by your transformation context instead. */
7785    const createBlock: (statements: readonly Statement[], multiLine?: boolean | undefined) => Block;
7786    /** @deprecated Use `factory.updateBlock` or the factory supplied by your transformation context instead. */
7787    const updateBlock: (node: Block, statements: readonly Statement[]) => Block;
7788    /** @deprecated Use `factory.createVariableStatement` or the factory supplied by your transformation context instead. */
7789    const createVariableStatement: (modifiers: readonly Modifier[] | undefined, declarationList: VariableDeclarationList | readonly VariableDeclaration[]) => VariableStatement;
7790    /** @deprecated Use `factory.updateVariableStatement` or the factory supplied by your transformation context instead. */
7791    const updateVariableStatement: (node: VariableStatement, modifiers: readonly Modifier[] | undefined, declarationList: VariableDeclarationList) => VariableStatement;
7792    /** @deprecated Use `factory.createEmptyStatement` or the factory supplied by your transformation context instead. */
7793    const createEmptyStatement: () => EmptyStatement;
7794    /** @deprecated Use `factory.createExpressionStatement` or the factory supplied by your transformation context instead. */
7795    const createExpressionStatement: (expression: Expression) => ExpressionStatement;
7796    /** @deprecated Use `factory.updateExpressionStatement` or the factory supplied by your transformation context instead. */
7797    const updateExpressionStatement: (node: ExpressionStatement, expression: Expression) => ExpressionStatement;
7798    /** @deprecated Use `factory.createExpressionStatement` or the factory supplied by your transformation context instead. */
7799    const createStatement: (expression: Expression) => ExpressionStatement;
7800    /** @deprecated Use `factory.updateExpressionStatement` or the factory supplied by your transformation context instead. */
7801    const updateStatement: (node: ExpressionStatement, expression: Expression) => ExpressionStatement;
7802    /** @deprecated Use `factory.createIfStatement` or the factory supplied by your transformation context instead. */
7803    const createIf: (expression: Expression, thenStatement: Statement, elseStatement?: Statement | undefined) => IfStatement;
7804    /** @deprecated Use `factory.updateIfStatement` or the factory supplied by your transformation context instead. */
7805    const updateIf: (node: IfStatement, expression: Expression, thenStatement: Statement, elseStatement: Statement | undefined) => IfStatement;
7806    /** @deprecated Use `factory.createDoStatement` or the factory supplied by your transformation context instead. */
7807    const createDo: (statement: Statement, expression: Expression) => DoStatement;
7808    /** @deprecated Use `factory.updateDoStatement` or the factory supplied by your transformation context instead. */
7809    const updateDo: (node: DoStatement, statement: Statement, expression: Expression) => DoStatement;
7810    /** @deprecated Use `factory.createWhileStatement` or the factory supplied by your transformation context instead. */
7811    const createWhile: (expression: Expression, statement: Statement) => WhileStatement;
7812    /** @deprecated Use `factory.updateWhileStatement` or the factory supplied by your transformation context instead. */
7813    const updateWhile: (node: WhileStatement, expression: Expression, statement: Statement) => WhileStatement;
7814    /** @deprecated Use `factory.createForStatement` or the factory supplied by your transformation context instead. */
7815    const createFor: (initializer: ForInitializer | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement) => ForStatement;
7816    /** @deprecated Use `factory.updateForStatement` or the factory supplied by your transformation context instead. */
7817    const updateFor: (node: ForStatement, initializer: ForInitializer | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement) => ForStatement;
7818    /** @deprecated Use `factory.createForInStatement` or the factory supplied by your transformation context instead. */
7819    const createForIn: (initializer: ForInitializer, expression: Expression, statement: Statement) => ForInStatement;
7820    /** @deprecated Use `factory.updateForInStatement` or the factory supplied by your transformation context instead. */
7821    const updateForIn: (node: ForInStatement, initializer: ForInitializer, expression: Expression, statement: Statement) => ForInStatement;
7822    /** @deprecated Use `factory.createForOfStatement` or the factory supplied by your transformation context instead. */
7823    const createForOf: (awaitModifier: AwaitKeyword | undefined, initializer: ForInitializer, expression: Expression, statement: Statement) => ForOfStatement;
7824    /** @deprecated Use `factory.updateForOfStatement` or the factory supplied by your transformation context instead. */
7825    const updateForOf: (node: ForOfStatement, awaitModifier: AwaitKeyword | undefined, initializer: ForInitializer, expression: Expression, statement: Statement) => ForOfStatement;
7826    /** @deprecated Use `factory.createContinueStatement` or the factory supplied by your transformation context instead. */
7827    const createContinue: (label?: string | Identifier | undefined) => ContinueStatement;
7828    /** @deprecated Use `factory.updateContinueStatement` or the factory supplied by your transformation context instead. */
7829    const updateContinue: (node: ContinueStatement, label: Identifier | undefined) => ContinueStatement;
7830    /** @deprecated Use `factory.createBreakStatement` or the factory supplied by your transformation context instead. */
7831    const createBreak: (label?: string | Identifier | undefined) => BreakStatement;
7832    /** @deprecated Use `factory.updateBreakStatement` or the factory supplied by your transformation context instead. */
7833    const updateBreak: (node: BreakStatement, label: Identifier | undefined) => BreakStatement;
7834    /** @deprecated Use `factory.createReturnStatement` or the factory supplied by your transformation context instead. */
7835    const createReturn: (expression?: Expression | undefined) => ReturnStatement;
7836    /** @deprecated Use `factory.updateReturnStatement` or the factory supplied by your transformation context instead. */
7837    const updateReturn: (node: ReturnStatement, expression: Expression | undefined) => ReturnStatement;
7838    /** @deprecated Use `factory.createWithStatement` or the factory supplied by your transformation context instead. */
7839    const createWith: (expression: Expression, statement: Statement) => WithStatement;
7840    /** @deprecated Use `factory.updateWithStatement` or the factory supplied by your transformation context instead. */
7841    const updateWith: (node: WithStatement, expression: Expression, statement: Statement) => WithStatement;
7842    /** @deprecated Use `factory.createSwitchStatement` or the factory supplied by your transformation context instead. */
7843    const createSwitch: (expression: Expression, caseBlock: CaseBlock) => SwitchStatement;
7844    /** @deprecated Use `factory.updateSwitchStatement` or the factory supplied by your transformation context instead. */
7845    const updateSwitch: (node: SwitchStatement, expression: Expression, caseBlock: CaseBlock) => SwitchStatement;
7846    /** @deprecated Use `factory.createLabelStatement` or the factory supplied by your transformation context instead. */
7847    const createLabel: (label: string | Identifier, statement: Statement) => LabeledStatement;
7848    /** @deprecated Use `factory.updateLabelStatement` or the factory supplied by your transformation context instead. */
7849    const updateLabel: (node: LabeledStatement, label: Identifier, statement: Statement) => LabeledStatement;
7850    /** @deprecated Use `factory.createThrowStatement` or the factory supplied by your transformation context instead. */
7851    const createThrow: (expression: Expression) => ThrowStatement;
7852    /** @deprecated Use `factory.updateThrowStatement` or the factory supplied by your transformation context instead. */
7853    const updateThrow: (node: ThrowStatement, expression: Expression) => ThrowStatement;
7854    /** @deprecated Use `factory.createTryStatement` or the factory supplied by your transformation context instead. */
7855    const createTry: (tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined) => TryStatement;
7856    /** @deprecated Use `factory.updateTryStatement` or the factory supplied by your transformation context instead. */
7857    const updateTry: (node: TryStatement, tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined) => TryStatement;
7858    /** @deprecated Use `factory.createDebuggerStatement` or the factory supplied by your transformation context instead. */
7859    const createDebuggerStatement: () => DebuggerStatement;
7860    /** @deprecated Use `factory.createVariableDeclarationList` or the factory supplied by your transformation context instead. */
7861    const createVariableDeclarationList: (declarations: readonly VariableDeclaration[], flags?: NodeFlags | undefined) => VariableDeclarationList;
7862    /** @deprecated Use `factory.updateVariableDeclarationList` or the factory supplied by your transformation context instead. */
7863    const updateVariableDeclarationList: (node: VariableDeclarationList, declarations: readonly VariableDeclaration[]) => VariableDeclarationList;
7864    /** @deprecated Use `factory.createFunctionDeclaration` or the factory supplied by your transformation context instead. */
7865    const createFunctionDeclaration: {
7866        (modifiers: readonly ModifierLike[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): FunctionDeclaration;
7867        (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): FunctionDeclaration;
7868    };
7869    /** @deprecated Use `factory.updateFunctionDeclaration` or the factory supplied by your transformation context instead. */
7870    const updateFunctionDeclaration: {
7871        (node: FunctionDeclaration, modifiers: readonly ModifierLike[] | undefined, asteriskToken: AsteriskToken | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): FunctionDeclaration;
7872        (node: FunctionDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): FunctionDeclaration;
7873    };
7874    /** @deprecated Use `factory.createClassDeclaration` or the factory supplied by your transformation context instead. */
7875    const createClassDeclaration: {
7876        (modifiers: readonly ModifierLike[] | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassDeclaration;
7877        (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassDeclaration;
7878    };
7879    /** @deprecated Use `factory.updateClassDeclaration` or the factory supplied by your transformation context instead. */
7880    const updateClassDeclaration: {
7881        (node: ClassDeclaration, modifiers: readonly ModifierLike[] | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassDeclaration;
7882        (node: ClassDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassDeclaration;
7883    };
7884    /** @deprecated Use `factory.createInterfaceDeclaration` or the factory supplied by your transformation context instead. */
7885    const createInterfaceDeclaration: {
7886        (modifiers: readonly Modifier[] | undefined, name: string | Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly TypeElement[]): InterfaceDeclaration;
7887        (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly TypeElement[]): InterfaceDeclaration;
7888    };
7889    /** @deprecated Use `factory.updateInterfaceDeclaration` or the factory supplied by your transformation context instead. */
7890    const updateInterfaceDeclaration: {
7891        (node: InterfaceDeclaration, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly TypeElement[]): InterfaceDeclaration;
7892        (node: InterfaceDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly TypeElement[]): InterfaceDeclaration;
7893    };
7894    /** @deprecated Use `factory.createTypeAliasDeclaration` or the factory supplied by your transformation context instead. */
7895    const createTypeAliasDeclaration: {
7896        (modifiers: readonly Modifier[] | undefined, name: string | Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration;
7897        (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration;
7898    };
7899    /** @deprecated Use `factory.updateTypeAliasDeclaration` or the factory supplied by your transformation context instead. */
7900    const updateTypeAliasDeclaration: {
7901        (node: TypeAliasDeclaration, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration;
7902        (node: TypeAliasDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration;
7903    };
7904    /** @deprecated Use `factory.createEnumDeclaration` or the factory supplied by your transformation context instead. */
7905    const createEnumDeclaration: {
7906        (modifiers: readonly Modifier[] | undefined, name: string | Identifier, members: readonly EnumMember[]): EnumDeclaration;
7907        (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, members: readonly EnumMember[]): EnumDeclaration;
7908    };
7909    /** @deprecated Use `factory.updateEnumDeclaration` or the factory supplied by your transformation context instead. */
7910    const updateEnumDeclaration: {
7911        (node: EnumDeclaration, modifiers: readonly Modifier[] | undefined, name: Identifier, members: readonly EnumMember[]): EnumDeclaration;
7912        (node: EnumDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, members: readonly EnumMember[]): EnumDeclaration;
7913    };
7914    /** @deprecated Use `factory.createModuleDeclaration` or the factory supplied by your transformation context instead. */
7915    const createModuleDeclaration: {
7916        (modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined, flags?: NodeFlags | undefined): ModuleDeclaration;
7917        (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined, flags?: NodeFlags | undefined): ModuleDeclaration;
7918    };
7919    /** @deprecated Use `factory.updateModuleDeclaration` or the factory supplied by your transformation context instead. */
7920    const updateModuleDeclaration: {
7921        (node: ModuleDeclaration, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined): ModuleDeclaration;
7922        (node: ModuleDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined): ModuleDeclaration;
7923    };
7924    /** @deprecated Use `factory.createModuleBlock` or the factory supplied by your transformation context instead. */
7925    const createModuleBlock: (statements: readonly Statement[]) => ModuleBlock;
7926    /** @deprecated Use `factory.updateModuleBlock` or the factory supplied by your transformation context instead. */
7927    const updateModuleBlock: (node: ModuleBlock, statements: readonly Statement[]) => ModuleBlock;
7928    /** @deprecated Use `factory.createCaseBlock` or the factory supplied by your transformation context instead. */
7929    const createCaseBlock: (clauses: readonly CaseOrDefaultClause[]) => CaseBlock;
7930    /** @deprecated Use `factory.updateCaseBlock` or the factory supplied by your transformation context instead. */
7931    const updateCaseBlock: (node: CaseBlock, clauses: readonly CaseOrDefaultClause[]) => CaseBlock;
7932    /** @deprecated Use `factory.createNamespaceExportDeclaration` or the factory supplied by your transformation context instead. */
7933    const createNamespaceExportDeclaration: (name: string | Identifier) => NamespaceExportDeclaration;
7934    /** @deprecated Use `factory.updateNamespaceExportDeclaration` or the factory supplied by your transformation context instead. */
7935    const updateNamespaceExportDeclaration: (node: NamespaceExportDeclaration, name: Identifier) => NamespaceExportDeclaration;
7936    /** @deprecated Use `factory.createImportEqualsDeclaration` or the factory supplied by your transformation context instead. */
7937    const createImportEqualsDeclaration: {
7938        (modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: string | Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration;
7939        (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: string | Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration;
7940    };
7941    /** @deprecated Use `factory.updateImportEqualsDeclaration` or the factory supplied by your transformation context instead. */
7942    const updateImportEqualsDeclaration: {
7943        (node: ImportEqualsDeclaration, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration;
7944        (node: ImportEqualsDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration;
7945    };
7946    /** @deprecated Use `factory.createImportDeclaration` or the factory supplied by your transformation context instead. */
7947    const createImportDeclaration: {
7948        (modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause?: AssertClause | undefined): ImportDeclaration;
7949        (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause?: AssertClause | undefined): ImportDeclaration;
7950    };
7951    /** @deprecated Use `factory.updateImportDeclaration` or the factory supplied by your transformation context instead. */
7952    const updateImportDeclaration: {
7953        (node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration;
7954        (node: ImportDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration;
7955    };
7956    /** @deprecated Use `factory.createNamespaceImport` or the factory supplied by your transformation context instead. */
7957    const createNamespaceImport: (name: Identifier) => NamespaceImport;
7958    /** @deprecated Use `factory.updateNamespaceImport` or the factory supplied by your transformation context instead. */
7959    const updateNamespaceImport: (node: NamespaceImport, name: Identifier) => NamespaceImport;
7960    /** @deprecated Use `factory.createNamedImports` or the factory supplied by your transformation context instead. */
7961    const createNamedImports: (elements: readonly ImportSpecifier[]) => NamedImports;
7962    /** @deprecated Use `factory.updateNamedImports` or the factory supplied by your transformation context instead. */
7963    const updateNamedImports: (node: NamedImports, elements: readonly ImportSpecifier[]) => NamedImports;
7964    /** @deprecated Use `factory.createImportSpecifier` or the factory supplied by your transformation context instead. */
7965    const createImportSpecifier: (isTypeOnly: boolean, propertyName: Identifier | undefined, name: Identifier) => ImportSpecifier;
7966    /** @deprecated Use `factory.updateImportSpecifier` or the factory supplied by your transformation context instead. */
7967    const updateImportSpecifier: (node: ImportSpecifier, isTypeOnly: boolean, propertyName: Identifier | undefined, name: Identifier) => ImportSpecifier;
7968    /** @deprecated Use `factory.createExportAssignment` or the factory supplied by your transformation context instead. */
7969    const createExportAssignment: {
7970        (modifiers: readonly Modifier[] | undefined, isExportEquals: boolean | undefined, expression: Expression): ExportAssignment;
7971        (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isExportEquals: boolean | undefined, expression: Expression): ExportAssignment;
7972    };
7973    /** @deprecated Use `factory.updateExportAssignment` or the factory supplied by your transformation context instead. */
7974    const updateExportAssignment: {
7975        (node: ExportAssignment, modifiers: readonly Modifier[] | undefined, expression: Expression): ExportAssignment;
7976        (node: ExportAssignment, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, expression: Expression): ExportAssignment;
7977    };
7978    /** @deprecated Use `factory.createNamedExports` or the factory supplied by your transformation context instead. */
7979    const createNamedExports: (elements: readonly ExportSpecifier[]) => NamedExports;
7980    /** @deprecated Use `factory.updateNamedExports` or the factory supplied by your transformation context instead. */
7981    const updateNamedExports: (node: NamedExports, elements: readonly ExportSpecifier[]) => NamedExports;
7982    /** @deprecated Use `factory.createExportSpecifier` or the factory supplied by your transformation context instead. */
7983    const createExportSpecifier: (isTypeOnly: boolean, propertyName: string | Identifier | undefined, name: string | Identifier) => ExportSpecifier;
7984    /** @deprecated Use `factory.updateExportSpecifier` or the factory supplied by your transformation context instead. */
7985    const updateExportSpecifier: (node: ExportSpecifier, isTypeOnly: boolean, propertyName: Identifier | undefined, name: Identifier) => ExportSpecifier;
7986    /** @deprecated Use `factory.createExternalModuleReference` or the factory supplied by your transformation context instead. */
7987    const createExternalModuleReference: (expression: Expression) => ExternalModuleReference;
7988    /** @deprecated Use `factory.updateExternalModuleReference` or the factory supplied by your transformation context instead. */
7989    const updateExternalModuleReference: (node: ExternalModuleReference, expression: Expression) => ExternalModuleReference;
7990    /** @deprecated Use `factory.createJSDocTypeExpression` or the factory supplied by your transformation context instead. */
7991    const createJSDocTypeExpression: (type: TypeNode) => JSDocTypeExpression;
7992    /** @deprecated Use `factory.createJSDocTypeTag` or the factory supplied by your transformation context instead. */
7993    const createJSDocTypeTag: (tagName: Identifier | undefined, typeExpression: JSDocTypeExpression, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocTypeTag;
7994    /** @deprecated Use `factory.createJSDocReturnTag` or the factory supplied by your transformation context instead. */
7995    const createJSDocReturnTag: (tagName: Identifier | undefined, typeExpression?: JSDocTypeExpression | undefined, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocReturnTag;
7996    /** @deprecated Use `factory.createJSDocThisTag` or the factory supplied by your transformation context instead. */
7997    const createJSDocThisTag: (tagName: Identifier | undefined, typeExpression: JSDocTypeExpression, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocThisTag;
7998    /** @deprecated Use `factory.createJSDocComment` or the factory supplied by your transformation context instead. */
7999    const createJSDocComment: (comment?: string | NodeArray<JSDocComment> | undefined, tags?: readonly JSDocTag[] | undefined) => JSDoc;
8000    /** @deprecated Use `factory.createJSDocParameterTag` or the factory supplied by your transformation context instead. */
8001    const createJSDocParameterTag: (tagName: Identifier | undefined, name: EntityName, isBracketed: boolean, typeExpression?: JSDocTypeExpression | undefined, isNameFirst?: boolean | undefined, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocParameterTag;
8002    /** @deprecated Use `factory.createJSDocClassTag` or the factory supplied by your transformation context instead. */
8003    const createJSDocClassTag: (tagName: Identifier | undefined, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocClassTag;
8004    /** @deprecated Use `factory.createJSDocAugmentsTag` or the factory supplied by your transformation context instead. */
8005    const createJSDocAugmentsTag: (tagName: Identifier | undefined, className: ExpressionWithTypeArguments & {
8006        readonly expression: Identifier | PropertyAccessEntityNameExpression;
8007    }, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocAugmentsTag;
8008    /** @deprecated Use `factory.createJSDocEnumTag` or the factory supplied by your transformation context instead. */
8009    const createJSDocEnumTag: (tagName: Identifier | undefined, typeExpression: JSDocTypeExpression, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocEnumTag;
8010    /** @deprecated Use `factory.createJSDocTemplateTag` or the factory supplied by your transformation context instead. */
8011    const createJSDocTemplateTag: (tagName: Identifier | undefined, constraint: JSDocTypeExpression | undefined, typeParameters: readonly TypeParameterDeclaration[], comment?: string | NodeArray<JSDocComment> | undefined) => JSDocTemplateTag;
8012    /** @deprecated Use `factory.createJSDocTypedefTag` or the factory supplied by your transformation context instead. */
8013    const createJSDocTypedefTag: (tagName: Identifier | undefined, typeExpression?: JSDocTypeLiteral | JSDocTypeExpression | undefined, fullName?: Identifier | JSDocNamespaceDeclaration | undefined, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocTypedefTag;
8014    /** @deprecated Use `factory.createJSDocCallbackTag` or the factory supplied by your transformation context instead. */
8015    const createJSDocCallbackTag: (tagName: Identifier | undefined, typeExpression: JSDocSignature, fullName?: Identifier | JSDocNamespaceDeclaration | undefined, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocCallbackTag;
8016    /** @deprecated Use `factory.createJSDocSignature` or the factory supplied by your transformation context instead. */
8017    const createJSDocSignature: (typeParameters: readonly JSDocTemplateTag[] | undefined, parameters: readonly JSDocParameterTag[], type?: JSDocReturnTag | undefined) => JSDocSignature;
8018    /** @deprecated Use `factory.createJSDocPropertyTag` or the factory supplied by your transformation context instead. */
8019    const createJSDocPropertyTag: (tagName: Identifier | undefined, name: EntityName, isBracketed: boolean, typeExpression?: JSDocTypeExpression | undefined, isNameFirst?: boolean | undefined, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocPropertyTag;
8020    /** @deprecated Use `factory.createJSDocTypeLiteral` or the factory supplied by your transformation context instead. */
8021    const createJSDocTypeLiteral: (jsDocPropertyTags?: readonly JSDocPropertyLikeTag[] | undefined, isArrayType?: boolean | undefined) => JSDocTypeLiteral;
8022    /** @deprecated Use `factory.createJSDocImplementsTag` or the factory supplied by your transformation context instead. */
8023    const createJSDocImplementsTag: (tagName: Identifier | undefined, className: ExpressionWithTypeArguments & {
8024        readonly expression: Identifier | PropertyAccessEntityNameExpression;
8025    }, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocImplementsTag;
8026    /** @deprecated Use `factory.createJSDocAuthorTag` or the factory supplied by your transformation context instead. */
8027    const createJSDocAuthorTag: (tagName: Identifier | undefined, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocAuthorTag;
8028    /** @deprecated Use `factory.createJSDocPublicTag` or the factory supplied by your transformation context instead. */
8029    const createJSDocPublicTag: (tagName: Identifier | undefined, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocPublicTag;
8030    /** @deprecated Use `factory.createJSDocPrivateTag` or the factory supplied by your transformation context instead. */
8031    const createJSDocPrivateTag: (tagName: Identifier | undefined, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocPrivateTag;
8032    /** @deprecated Use `factory.createJSDocProtectedTag` or the factory supplied by your transformation context instead. */
8033    const createJSDocProtectedTag: (tagName: Identifier | undefined, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocProtectedTag;
8034    /** @deprecated Use `factory.createJSDocReadonlyTag` or the factory supplied by your transformation context instead. */
8035    const createJSDocReadonlyTag: (tagName: Identifier | undefined, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocReadonlyTag;
8036    /** @deprecated Use `factory.createJSDocUnknownTag` or the factory supplied by your transformation context instead. */
8037    const createJSDocTag: (tagName: Identifier, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocUnknownTag;
8038    /** @deprecated Use `factory.createJsxElement` or the factory supplied by your transformation context instead. */
8039    const createJsxElement: (openingElement: JsxOpeningElement, children: readonly JsxChild[], closingElement: JsxClosingElement) => JsxElement;
8040    /** @deprecated Use `factory.updateJsxElement` or the factory supplied by your transformation context instead. */
8041    const updateJsxElement: (node: JsxElement, openingElement: JsxOpeningElement, children: readonly JsxChild[], closingElement: JsxClosingElement) => JsxElement;
8042    /** @deprecated Use `factory.createJsxSelfClosingElement` or the factory supplied by your transformation context instead. */
8043    const createJsxSelfClosingElement: (tagName: JsxTagNameExpression, typeArguments: readonly TypeNode[] | undefined, attributes: JsxAttributes) => JsxSelfClosingElement;
8044    /** @deprecated Use `factory.updateJsxSelfClosingElement` or the factory supplied by your transformation context instead. */
8045    const updateJsxSelfClosingElement: (node: JsxSelfClosingElement, tagName: JsxTagNameExpression, typeArguments: readonly TypeNode[] | undefined, attributes: JsxAttributes) => JsxSelfClosingElement;
8046    /** @deprecated Use `factory.createJsxOpeningElement` or the factory supplied by your transformation context instead. */
8047    const createJsxOpeningElement: (tagName: JsxTagNameExpression, typeArguments: readonly TypeNode[] | undefined, attributes: JsxAttributes) => JsxOpeningElement;
8048    /** @deprecated Use `factory.updateJsxOpeningElement` or the factory supplied by your transformation context instead. */
8049    const updateJsxOpeningElement: (node: JsxOpeningElement, tagName: JsxTagNameExpression, typeArguments: readonly TypeNode[] | undefined, attributes: JsxAttributes) => JsxOpeningElement;
8050    /** @deprecated Use `factory.createJsxClosingElement` or the factory supplied by your transformation context instead. */
8051    const createJsxClosingElement: (tagName: JsxTagNameExpression) => JsxClosingElement;
8052    /** @deprecated Use `factory.updateJsxClosingElement` or the factory supplied by your transformation context instead. */
8053    const updateJsxClosingElement: (node: JsxClosingElement, tagName: JsxTagNameExpression) => JsxClosingElement;
8054    /** @deprecated Use `factory.createJsxFragment` or the factory supplied by your transformation context instead. */
8055    const createJsxFragment: (openingFragment: JsxOpeningFragment, children: readonly JsxChild[], closingFragment: JsxClosingFragment) => JsxFragment;
8056    /** @deprecated Use `factory.createJsxText` or the factory supplied by your transformation context instead. */
8057    const createJsxText: (text: string, containsOnlyTriviaWhiteSpaces?: boolean | undefined) => JsxText;
8058    /** @deprecated Use `factory.updateJsxText` or the factory supplied by your transformation context instead. */
8059    const updateJsxText: (node: JsxText, text: string, containsOnlyTriviaWhiteSpaces?: boolean | undefined) => JsxText;
8060    /** @deprecated Use `factory.createJsxOpeningFragment` or the factory supplied by your transformation context instead. */
8061    const createJsxOpeningFragment: () => JsxOpeningFragment;
8062    /** @deprecated Use `factory.createJsxJsxClosingFragment` or the factory supplied by your transformation context instead. */
8063    const createJsxJsxClosingFragment: () => JsxClosingFragment;
8064    /** @deprecated Use `factory.updateJsxFragment` or the factory supplied by your transformation context instead. */
8065    const updateJsxFragment: (node: JsxFragment, openingFragment: JsxOpeningFragment, children: readonly JsxChild[], closingFragment: JsxClosingFragment) => JsxFragment;
8066    /** @deprecated Use `factory.createJsxAttribute` or the factory supplied by your transformation context instead. */
8067    const createJsxAttribute: (name: Identifier, initializer: JsxAttributeValue | undefined) => JsxAttribute;
8068    /** @deprecated Use `factory.updateJsxAttribute` or the factory supplied by your transformation context instead. */
8069    const updateJsxAttribute: (node: JsxAttribute, name: Identifier, initializer: JsxAttributeValue | undefined) => JsxAttribute;
8070    /** @deprecated Use `factory.createJsxAttributes` or the factory supplied by your transformation context instead. */
8071    const createJsxAttributes: (properties: readonly JsxAttributeLike[]) => JsxAttributes;
8072    /** @deprecated Use `factory.updateJsxAttributes` or the factory supplied by your transformation context instead. */
8073    const updateJsxAttributes: (node: JsxAttributes, properties: readonly JsxAttributeLike[]) => JsxAttributes;
8074    /** @deprecated Use `factory.createJsxSpreadAttribute` or the factory supplied by your transformation context instead. */
8075    const createJsxSpreadAttribute: (expression: Expression) => JsxSpreadAttribute;
8076    /** @deprecated Use `factory.updateJsxSpreadAttribute` or the factory supplied by your transformation context instead. */
8077    const updateJsxSpreadAttribute: (node: JsxSpreadAttribute, expression: Expression) => JsxSpreadAttribute;
8078    /** @deprecated Use `factory.createJsxExpression` or the factory supplied by your transformation context instead. */
8079    const createJsxExpression: (dotDotDotToken: DotDotDotToken | undefined, expression: Expression | undefined) => JsxExpression;
8080    /** @deprecated Use `factory.updateJsxExpression` or the factory supplied by your transformation context instead. */
8081    const updateJsxExpression: (node: JsxExpression, expression: Expression | undefined) => JsxExpression;
8082    /** @deprecated Use `factory.createCaseClause` or the factory supplied by your transformation context instead. */
8083    const createCaseClause: (expression: Expression, statements: readonly Statement[]) => CaseClause;
8084    /** @deprecated Use `factory.updateCaseClause` or the factory supplied by your transformation context instead. */
8085    const updateCaseClause: (node: CaseClause, expression: Expression, statements: readonly Statement[]) => CaseClause;
8086    /** @deprecated Use `factory.createDefaultClause` or the factory supplied by your transformation context instead. */
8087    const createDefaultClause: (statements: readonly Statement[]) => DefaultClause;
8088    /** @deprecated Use `factory.updateDefaultClause` or the factory supplied by your transformation context instead. */
8089    const updateDefaultClause: (node: DefaultClause, statements: readonly Statement[]) => DefaultClause;
8090    /** @deprecated Use `factory.createHeritageClause` or the factory supplied by your transformation context instead. */
8091    const createHeritageClause: (token: SyntaxKind.ExtendsKeyword | SyntaxKind.ImplementsKeyword, types: readonly ExpressionWithTypeArguments[]) => HeritageClause;
8092    /** @deprecated Use `factory.updateHeritageClause` or the factory supplied by your transformation context instead. */
8093    const updateHeritageClause: (node: HeritageClause, types: readonly ExpressionWithTypeArguments[]) => HeritageClause;
8094    /** @deprecated Use `factory.createCatchClause` or the factory supplied by your transformation context instead. */
8095    const createCatchClause: (variableDeclaration: string | VariableDeclaration | BindingName | undefined, block: Block) => CatchClause;
8096    /** @deprecated Use `factory.updateCatchClause` or the factory supplied by your transformation context instead. */
8097    const updateCatchClause: (node: CatchClause, variableDeclaration: VariableDeclaration | undefined, block: Block) => CatchClause;
8098    /** @deprecated Use `factory.createPropertyAssignment` or the factory supplied by your transformation context instead. */
8099    const createPropertyAssignment: (name: string | PropertyName, initializer: Expression) => PropertyAssignment;
8100    /** @deprecated Use `factory.updatePropertyAssignment` or the factory supplied by your transformation context instead. */
8101    const updatePropertyAssignment: (node: PropertyAssignment, name: PropertyName, initializer: Expression) => PropertyAssignment;
8102    /** @deprecated Use `factory.createShorthandPropertyAssignment` or the factory supplied by your transformation context instead. */
8103    const createShorthandPropertyAssignment: (name: string | Identifier, objectAssignmentInitializer?: Expression | undefined) => ShorthandPropertyAssignment;
8104    /** @deprecated Use `factory.updateShorthandPropertyAssignment` or the factory supplied by your transformation context instead. */
8105    const updateShorthandPropertyAssignment: (node: ShorthandPropertyAssignment, name: Identifier, objectAssignmentInitializer: Expression | undefined) => ShorthandPropertyAssignment;
8106    /** @deprecated Use `factory.createSpreadAssignment` or the factory supplied by your transformation context instead. */
8107    const createSpreadAssignment: (expression: Expression) => SpreadAssignment;
8108    /** @deprecated Use `factory.updateSpreadAssignment` or the factory supplied by your transformation context instead. */
8109    const updateSpreadAssignment: (node: SpreadAssignment, expression: Expression) => SpreadAssignment;
8110    /** @deprecated Use `factory.createEnumMember` or the factory supplied by your transformation context instead. */
8111    const createEnumMember: (name: string | PropertyName, initializer?: Expression | undefined) => EnumMember;
8112    /** @deprecated Use `factory.updateEnumMember` or the factory supplied by your transformation context instead. */
8113    const updateEnumMember: (node: EnumMember, name: PropertyName, initializer: Expression | undefined) => EnumMember;
8114    /** @deprecated Use `factory.updateSourceFile` or the factory supplied by your transformation context instead. */
8115    const updateSourceFileNode: (node: SourceFile, statements: readonly Statement[], isDeclarationFile?: boolean | undefined, referencedFiles?: readonly FileReference[] | undefined, typeReferences?: readonly FileReference[] | undefined, hasNoDefaultLib?: boolean | undefined, libReferences?: readonly FileReference[] | undefined) => SourceFile;
8116    /** @deprecated Use `factory.createNotEmittedStatement` or the factory supplied by your transformation context instead. */
8117    const createNotEmittedStatement: (original: Node) => NotEmittedStatement;
8118    /** @deprecated Use `factory.createPartiallyEmittedExpression` or the factory supplied by your transformation context instead. */
8119    const createPartiallyEmittedExpression: (expression: Expression, original?: Node | undefined) => PartiallyEmittedExpression;
8120    /** @deprecated Use `factory.updatePartiallyEmittedExpression` or the factory supplied by your transformation context instead. */
8121    const updatePartiallyEmittedExpression: (node: PartiallyEmittedExpression, expression: Expression) => PartiallyEmittedExpression;
8122    /** @deprecated Use `factory.createCommaListExpression` or the factory supplied by your transformation context instead. */
8123    const createCommaList: (elements: readonly Expression[]) => CommaListExpression;
8124    /** @deprecated Use `factory.updateCommaListExpression` or the factory supplied by your transformation context instead. */
8125    const updateCommaList: (node: CommaListExpression, elements: readonly Expression[]) => CommaListExpression;
8126    /** @deprecated Use `factory.createBundle` or the factory supplied by your transformation context instead. */
8127    const createBundle: (sourceFiles: readonly SourceFile[], prepends?: readonly (UnparsedSource | InputFiles)[] | undefined) => Bundle;
8128    /** @deprecated Use `factory.updateBundle` or the factory supplied by your transformation context instead. */
8129    const updateBundle: (node: Bundle, sourceFiles: readonly SourceFile[], prepends?: readonly (UnparsedSource | InputFiles)[] | undefined) => Bundle;
8130    /** @deprecated Use `factory.createImmediatelyInvokedFunctionExpression` or the factory supplied by your transformation context instead. */
8131    const createImmediatelyInvokedFunctionExpression: {
8132        (statements: readonly Statement[]): CallExpression;
8133        (statements: readonly Statement[], param: ParameterDeclaration, paramValue: Expression): CallExpression;
8134    };
8135    /** @deprecated Use `factory.createImmediatelyInvokedArrowFunction` or the factory supplied by your transformation context instead. */
8136    const createImmediatelyInvokedArrowFunction: {
8137        (statements: readonly Statement[]): CallExpression;
8138        (statements: readonly Statement[], param: ParameterDeclaration, paramValue: Expression): CallExpression;
8139    };
8140    /** @deprecated Use `factory.createVoidZero` or the factory supplied by your transformation context instead. */
8141    const createVoidZero: () => VoidExpression;
8142    /** @deprecated Use `factory.createExportDefault` or the factory supplied by your transformation context instead. */
8143    const createExportDefault: (expression: Expression) => ExportAssignment;
8144    /** @deprecated Use `factory.createExternalModuleExport` or the factory supplied by your transformation context instead. */
8145    const createExternalModuleExport: (exportName: Identifier) => ExportDeclaration;
8146    /** @deprecated Use `factory.createNamespaceExport` or the factory supplied by your transformation context instead. */
8147    const createNamespaceExport: (name: Identifier) => NamespaceExport;
8148    /** @deprecated Use `factory.updateNamespaceExport` or the factory supplied by your transformation context instead. */
8149    const updateNamespaceExport: (node: NamespaceExport, name: Identifier) => NamespaceExport;
8150    /** @deprecated Use `factory.createToken` or the factory supplied by your transformation context instead. */
8151    const createToken: <TKind extends SyntaxKind>(kind: TKind) => Token<TKind>;
8152    /** @deprecated Use `factory.createIdentifier` or the factory supplied by your transformation context instead. */
8153    const createIdentifier: (text: string) => Identifier;
8154    /** @deprecated Use `factory.createTempVariable` or the factory supplied by your transformation context instead. */
8155    const createTempVariable: (recordTempVariable: ((node: Identifier) => void) | undefined) => Identifier;
8156    /** @deprecated Use `factory.getGeneratedNameForNode` or the factory supplied by your transformation context instead. */
8157    const getGeneratedNameForNode: (node: Node | undefined) => Identifier;
8158    /** @deprecated Use `factory.createUniqueName(text, GeneratedIdentifierFlags.Optimistic)` or the factory supplied by your transformation context instead. */
8159    const createOptimisticUniqueName: (text: string) => Identifier;
8160    /** @deprecated Use `factory.createUniqueName(text, GeneratedIdentifierFlags.Optimistic | GeneratedIdentifierFlags.FileLevel)` or the factory supplied by your transformation context instead. */
8161    const createFileLevelUniqueName: (text: string) => Identifier;
8162    /** @deprecated Use `factory.createIndexSignature` or the factory supplied by your transformation context instead. */
8163    const createIndexSignature: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode) => IndexSignatureDeclaration;
8164    /** @deprecated Use `factory.createTypePredicateNode` or the factory supplied by your transformation context instead. */
8165    const createTypePredicateNode: (parameterName: Identifier | ThisTypeNode | string, type: TypeNode) => TypePredicateNode;
8166    /** @deprecated Use `factory.updateTypePredicateNode` or the factory supplied by your transformation context instead. */
8167    const updateTypePredicateNode: (node: TypePredicateNode, parameterName: Identifier | ThisTypeNode, type: TypeNode) => TypePredicateNode;
8168    /** @deprecated Use `factory.createStringLiteral`, `factory.createStringLiteralFromNode`, `factory.createNumericLiteral`, `factory.createBigIntLiteral`, `factory.createTrue`, `factory.createFalse`, or the factory supplied by your transformation context instead. */
8169    const createLiteral: {
8170        (value: string | StringLiteral | NoSubstitutionTemplateLiteral | NumericLiteral | Identifier): StringLiteral;
8171        (value: number | PseudoBigInt): NumericLiteral;
8172        (value: boolean): BooleanLiteral;
8173        (value: string | number | PseudoBigInt | boolean): PrimaryExpression;
8174    };
8175    /** @deprecated Use `factory.createMethodSignature` or the factory supplied by your transformation context instead. */
8176    const createMethodSignature: (typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, name: string | PropertyName, questionToken: QuestionToken | undefined) => MethodSignature;
8177    /** @deprecated Use `factory.updateMethodSignature` or the factory supplied by your transformation context instead. */
8178    const updateMethodSignature: (node: MethodSignature, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined, name: PropertyName, questionToken: QuestionToken | undefined) => MethodSignature;
8179    /** @deprecated Use `factory.createTypeOperatorNode` or the factory supplied by your transformation context instead. */
8180    const createTypeOperatorNode: {
8181        (type: TypeNode): TypeOperatorNode;
8182        (operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword, type: TypeNode): TypeOperatorNode;
8183    };
8184    /** @deprecated Use `factory.createTaggedTemplate` or the factory supplied by your transformation context instead. */
8185    const createTaggedTemplate: {
8186        (tag: Expression, template: TemplateLiteral): TaggedTemplateExpression;
8187        (tag: Expression, typeArguments: readonly TypeNode[] | undefined, template: TemplateLiteral): TaggedTemplateExpression;
8188    };
8189    /** @deprecated Use `factory.updateTaggedTemplate` or the factory supplied by your transformation context instead. */
8190    const updateTaggedTemplate: {
8191        (node: TaggedTemplateExpression, tag: Expression, template: TemplateLiteral): TaggedTemplateExpression;
8192        (node: TaggedTemplateExpression, tag: Expression, typeArguments: readonly TypeNode[] | undefined, template: TemplateLiteral): TaggedTemplateExpression;
8193    };
8194    /** @deprecated Use `factory.updateBinary` or the factory supplied by your transformation context instead. */
8195    const updateBinary: (node: BinaryExpression, left: Expression, right: Expression, operator?: BinaryOperator | BinaryOperatorToken) => BinaryExpression;
8196    /** @deprecated Use `factory.createConditional` or the factory supplied by your transformation context instead. */
8197    const createConditional: {
8198        (condition: Expression, whenTrue: Expression, whenFalse: Expression): ConditionalExpression;
8199        (condition: Expression, questionToken: QuestionToken, whenTrue: Expression, colonToken: ColonToken, whenFalse: Expression): ConditionalExpression;
8200    };
8201    /** @deprecated Use `factory.createYield` or the factory supplied by your transformation context instead. */
8202    const createYield: {
8203        (expression?: Expression | undefined): YieldExpression;
8204        (asteriskToken: AsteriskToken | undefined, expression: Expression): YieldExpression;
8205    };
8206    /** @deprecated Use `factory.createClassExpression` or the factory supplied by your transformation context instead. */
8207    const createClassExpression: (modifiers: readonly Modifier[] | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]) => ClassExpression;
8208    /** @deprecated Use `factory.updateClassExpression` or the factory supplied by your transformation context instead. */
8209    const updateClassExpression: (node: ClassExpression, modifiers: readonly Modifier[] | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]) => ClassExpression;
8210    /** @deprecated Use `factory.createPropertySignature` or the factory supplied by your transformation context instead. */
8211    const createPropertySignature: (modifiers: readonly Modifier[] | undefined, name: PropertyName | string, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer?: Expression | undefined) => PropertySignature;
8212    /** @deprecated Use `factory.updatePropertySignature` or the factory supplied by your transformation context instead. */
8213    const updatePropertySignature: (node: PropertySignature, modifiers: readonly Modifier[] | undefined, name: PropertyName, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined) => PropertySignature;
8214    /** @deprecated Use `factory.createExpressionWithTypeArguments` or the factory supplied by your transformation context instead. */
8215    const createExpressionWithTypeArguments: (typeArguments: readonly TypeNode[] | undefined, expression: Expression) => ExpressionWithTypeArguments;
8216    /** @deprecated Use `factory.updateExpressionWithTypeArguments` or the factory supplied by your transformation context instead. */
8217    const updateExpressionWithTypeArguments: (node: ExpressionWithTypeArguments, typeArguments: readonly TypeNode[] | undefined, expression: Expression) => ExpressionWithTypeArguments;
8218    /** @deprecated Use `factory.createArrowFunction` or the factory supplied by your transformation context instead. */
8219    const createArrowFunction: {
8220        (modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, equalsGreaterThanToken: EqualsGreaterThanToken | undefined, body: ConciseBody): ArrowFunction;
8221        (modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: ConciseBody): ArrowFunction;
8222    };
8223    /** @deprecated Use `factory.updateArrowFunction` or the factory supplied by your transformation context instead. */
8224    const updateArrowFunction: {
8225        (node: ArrowFunction, modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, equalsGreaterThanToken: EqualsGreaterThanToken, body: ConciseBody): ArrowFunction;
8226        (node: ArrowFunction, modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: ConciseBody): ArrowFunction;
8227    };
8228    /** @deprecated Use `factory.createVariableDeclaration` or the factory supplied by your transformation context instead. */
8229    const createVariableDeclaration: {
8230        (name: string | BindingName, type?: TypeNode | undefined, initializer?: Expression | undefined): VariableDeclaration;
8231        (name: string | BindingName, exclamationToken: ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): VariableDeclaration;
8232    };
8233    /** @deprecated Use `factory.updateVariableDeclaration` or the factory supplied by your transformation context instead. */
8234    const updateVariableDeclaration: {
8235        (node: VariableDeclaration, name: BindingName, type: TypeNode | undefined, initializer: Expression | undefined): VariableDeclaration;
8236        (node: VariableDeclaration, name: BindingName, exclamationToken: ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): VariableDeclaration;
8237    };
8238    /** @deprecated Use `factory.createImportClause` or the factory supplied by your transformation context instead. */
8239    const createImportClause: (name: Identifier | undefined, namedBindings: NamedImportBindings | undefined, isTypeOnly?: any) => ImportClause;
8240    /** @deprecated Use `factory.updateImportClause` or the factory supplied by your transformation context instead. */
8241    const updateImportClause: (node: ImportClause, name: Identifier | undefined, namedBindings: NamedImportBindings | undefined, isTypeOnly: boolean) => ImportClause;
8242    /** @deprecated Use `factory.createExportDeclaration` or the factory supplied by your transformation context instead. */
8243    const createExportDeclaration: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, exportClause: NamedExportBindings | undefined, moduleSpecifier?: Expression | undefined, isTypeOnly?: any) => ExportDeclaration;
8244    /** @deprecated Use `factory.updateExportDeclaration` or the factory supplied by your transformation context instead. */
8245    const updateExportDeclaration: (node: ExportDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, exportClause: NamedExportBindings | undefined, moduleSpecifier: Expression | undefined, isTypeOnly: boolean) => ExportDeclaration;
8246    /** @deprecated Use `factory.createJSDocParameterTag` or the factory supplied by your transformation context instead. */
8247    const createJSDocParamTag: (name: EntityName, isBracketed: boolean, typeExpression?: JSDocTypeExpression | undefined, comment?: string | undefined) => JSDocParameterTag;
8248    /** @deprecated Use `factory.createComma` or the factory supplied by your transformation context instead. */
8249    const createComma: (left: Expression, right: Expression) => Expression;
8250    /** @deprecated Use `factory.createLessThan` or the factory supplied by your transformation context instead. */
8251    const createLessThan: (left: Expression, right: Expression) => Expression;
8252    /** @deprecated Use `factory.createAssignment` or the factory supplied by your transformation context instead. */
8253    const createAssignment: (left: Expression, right: Expression) => BinaryExpression;
8254    /** @deprecated Use `factory.createStrictEquality` or the factory supplied by your transformation context instead. */
8255    const createStrictEquality: (left: Expression, right: Expression) => BinaryExpression;
8256    /** @deprecated Use `factory.createStrictInequality` or the factory supplied by your transformation context instead. */
8257    const createStrictInequality: (left: Expression, right: Expression) => BinaryExpression;
8258    /** @deprecated Use `factory.createAdd` or the factory supplied by your transformation context instead. */
8259    const createAdd: (left: Expression, right: Expression) => BinaryExpression;
8260    /** @deprecated Use `factory.createSubtract` or the factory supplied by your transformation context instead. */
8261    const createSubtract: (left: Expression, right: Expression) => BinaryExpression;
8262    /** @deprecated Use `factory.createLogicalAnd` or the factory supplied by your transformation context instead. */
8263    const createLogicalAnd: (left: Expression, right: Expression) => BinaryExpression;
8264    /** @deprecated Use `factory.createLogicalOr` or the factory supplied by your transformation context instead. */
8265    const createLogicalOr: (left: Expression, right: Expression) => BinaryExpression;
8266    /** @deprecated Use `factory.createPostfixIncrement` or the factory supplied by your transformation context instead. */
8267    const createPostfixIncrement: (operand: Expression) => PostfixUnaryExpression;
8268    /** @deprecated Use `factory.createLogicalNot` or the factory supplied by your transformation context instead. */
8269    const createLogicalNot: (operand: Expression) => PrefixUnaryExpression;
8270    /** @deprecated Use an appropriate `factory` method instead. */
8271    const createNode: (kind: SyntaxKind, pos?: any, end?: any) => Node;
8272    /**
8273     * Creates a shallow, memberwise clone of a node ~for mutation~ with its `pos`, `end`, and `parent` set.
8274     *
8275     * NOTE: It is unsafe to change any properties of a `Node` that relate to its AST children, as those changes won't be
8276     * captured with respect to transformations.
8277     *
8278     * @deprecated Use an appropriate `factory.update...` method instead, use `setCommentRange` or `setSourceMapRange`, and avoid setting `parent`.
8279     */
8280    const getMutableClone: <T extends Node>(node: T) => T;
8281}
8282declare namespace ts {
8283    /** @deprecated Use `isTypeAssertionExpression` instead. */
8284    const isTypeAssertion: (node: Node) => node is TypeAssertion;
8285}
8286declare namespace ts {
8287    /**
8288     * @deprecated Use `ts.ReadonlyESMap<K, V>` instead.
8289     */
8290    interface ReadonlyMap<T> extends ReadonlyESMap<string, T> {
8291    }
8292    /**
8293     * @deprecated Use `ts.ESMap<K, V>` instead.
8294     */
8295    interface Map<T> extends ESMap<string, T> {
8296    }
8297}
8298declare namespace ts {
8299    /**
8300     * @deprecated Use `isMemberName` instead.
8301     */
8302    const isIdentifierOrPrivateIdentifier: (node: Node) => node is MemberName;
8303}
8304declare namespace ts {
8305    interface NodeFactory {
8306        /** @deprecated Use the overload that accepts 'modifiers' */
8307        createConstructorTypeNode(typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): ConstructorTypeNode;
8308        /** @deprecated Use the overload that accepts 'modifiers' */
8309        updateConstructorTypeNode(node: ConstructorTypeNode, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode): ConstructorTypeNode;
8310    }
8311}
8312declare namespace ts {
8313    interface NodeFactory {
8314        createImportTypeNode(argument: TypeNode, assertions?: ImportTypeAssertionContainer, qualifier?: EntityName, typeArguments?: readonly TypeNode[], isTypeOf?: boolean): ImportTypeNode;
8315        /** @deprecated Use the overload that accepts 'assertions' */
8316        createImportTypeNode(argument: TypeNode, qualifier?: EntityName, typeArguments?: readonly TypeNode[], isTypeOf?: boolean): ImportTypeNode;
8317        /** @deprecated Use the overload that accepts 'assertions' */
8318        updateImportTypeNode(node: ImportTypeNode, argument: TypeNode, qualifier: EntityName | undefined, typeArguments: readonly TypeNode[] | undefined, isTypeOf?: boolean): ImportTypeNode;
8319    }
8320}
8321declare namespace ts {
8322    interface NodeFactory {
8323        /** @deprecated Use the overload that accepts 'modifiers' */
8324        createTypeParameterDeclaration(name: string | Identifier, constraint?: TypeNode, defaultType?: TypeNode): TypeParameterDeclaration;
8325        /** @deprecated Use the overload that accepts 'modifiers' */
8326        updateTypeParameterDeclaration(node: TypeParameterDeclaration, name: Identifier, constraint: TypeNode | undefined, defaultType: TypeNode | undefined): TypeParameterDeclaration;
8327    }
8328}
8329declare namespace ts {
8330    interface Node {
8331        /**
8332         * @deprecated `decorators` has been removed from `Node` and merged with `modifiers` on the `Node` subtypes that support them.
8333         * Use `ts.canHaveDecorators()` to test whether a `Node` can have decorators.
8334         * Use `ts.getDecorators()` to get the decorators of a `Node`.
8335         *
8336         * For example:
8337         * ```ts
8338         * const decorators = ts.canHaveDecorators(node) ? ts.getDecorators(node) : undefined;
8339         * ```
8340         */
8341        readonly decorators?: undefined;
8342        /**
8343         * @deprecated `modifiers` has been removed from `Node` and moved to the `Node` subtypes that support them.
8344         * Use `ts.canHaveModifiers()` to test whether a `Node` can have modifiers.
8345         * Use `ts.getModifiers()` to get the modifiers of a `Node`.
8346         *
8347         * For example:
8348         * ```ts
8349         * const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
8350         * ```
8351         */
8352        readonly modifiers?: NodeArray<ModifierLike> | undefined;
8353    }
8354    interface PropertySignature {
8355        /** @deprecated A property signature cannot have an initializer */
8356        readonly initializer?: Expression | undefined;
8357    }
8358    interface PropertyAssignment {
8359        /** @deprecated A property assignment cannot have a question token */
8360        readonly questionToken?: QuestionToken | undefined;
8361        /** @deprecated A property assignment cannot have an exclamation token */
8362        readonly exclamationToken?: ExclamationToken | undefined;
8363    }
8364    interface ShorthandPropertyAssignment {
8365        /** @deprecated A shorthand property assignment cannot have modifiers */
8366        readonly modifiers?: NodeArray<Modifier> | undefined;
8367        /** @deprecated A shorthand property assignment cannot have a question token */
8368        readonly questionToken?: QuestionToken | undefined;
8369        /** @deprecated A shorthand property assignment cannot have an exclamation token */
8370        readonly exclamationToken?: ExclamationToken | undefined;
8371    }
8372    interface FunctionTypeNode {
8373        /** @deprecated A function type cannot have modifiers */
8374        readonly modifiers?: NodeArray<Modifier> | undefined;
8375    }
8376    interface NodeFactory {
8377        /**
8378         * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
8379         */
8380        createParameterDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken?: QuestionToken, type?: TypeNode, initializer?: Expression): ParameterDeclaration;
8381        /**
8382         * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
8383         */
8384        updateParameterDeclaration(node: ParameterDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): ParameterDeclaration;
8385        /**
8386         * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
8387         */
8388        createPropertyDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertyDeclaration;
8389        /**
8390         * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
8391         */
8392        updatePropertyDeclaration(node: PropertyDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertyDeclaration;
8393        /**
8394         * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
8395         */
8396        createMethodDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | PropertyName, questionToken: QuestionToken | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): MethodDeclaration;
8397        /**
8398         * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
8399         */
8400        updateMethodDeclaration(node: MethodDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: PropertyName, questionToken: QuestionToken | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): MethodDeclaration;
8401        /**
8402         * @deprecated This node does not support Decorators. Callers should use an overload that does not accept a `decorators` parameter.
8403         */
8404        createConstructorDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], body: Block | undefined): ConstructorDeclaration;
8405        /**
8406         * @deprecated This node does not support Decorators. Callers should use an overload that does not accept a `decorators` parameter.
8407         */
8408        updateConstructorDeclaration(node: ConstructorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], body: Block | undefined): ConstructorDeclaration;
8409        /**
8410         * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
8411         */
8412        createGetAccessorDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): GetAccessorDeclaration;
8413        /**
8414         * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
8415         */
8416        updateGetAccessorDeclaration(node: GetAccessorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: PropertyName, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): GetAccessorDeclaration;
8417        /**
8418         * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
8419         */
8420        createSetAccessorDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, parameters: readonly ParameterDeclaration[], body: Block | undefined): SetAccessorDeclaration;
8421        /**
8422         * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
8423         */
8424        updateSetAccessorDeclaration(node: SetAccessorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: PropertyName, parameters: readonly ParameterDeclaration[], body: Block | undefined): SetAccessorDeclaration;
8425        /**
8426         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8427         */
8428        createIndexSignature(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration;
8429        /**
8430         * @deprecated Decorators and modifiers are no longer supported for this function. Callers should use an overload that does not accept the `decorators` and `modifiers` parameters.
8431         */
8432        updateIndexSignature(node: IndexSignatureDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration;
8433        /**
8434         * @deprecated Decorators and modifiers are no longer supported for this function. Callers should use an overload that does not accept the `decorators` and `modifiers` parameters.
8435         */
8436        createClassStaticBlockDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, body: Block): ClassStaticBlockDeclaration;
8437        /**
8438         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8439         */
8440        updateClassStaticBlockDeclaration(node: ClassStaticBlockDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, body: Block): ClassStaticBlockDeclaration;
8441        /**
8442         * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
8443         */
8444        createClassExpression(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassExpression;
8445        /**
8446         * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
8447         */
8448        updateClassExpression(node: ClassExpression, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassExpression;
8449        /**
8450         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8451         */
8452        createFunctionDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): FunctionDeclaration;
8453        /**
8454         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8455         */
8456        updateFunctionDeclaration(node: FunctionDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): FunctionDeclaration;
8457        /**
8458         * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
8459         */
8460        createClassDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassDeclaration;
8461        /**
8462         * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
8463         */
8464        updateClassDeclaration(node: ClassDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassDeclaration;
8465        /**
8466         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8467         */
8468        createInterfaceDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly TypeElement[]): InterfaceDeclaration;
8469        /**
8470         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8471         */
8472        updateInterfaceDeclaration(node: InterfaceDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly TypeElement[]): InterfaceDeclaration;
8473        /**
8474         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8475         */
8476        createTypeAliasDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration;
8477        /**
8478         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8479         */
8480        updateTypeAliasDeclaration(node: TypeAliasDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration;
8481        /**
8482         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8483         */
8484        createEnumDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, members: readonly EnumMember[]): EnumDeclaration;
8485        /**
8486         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8487         */
8488        updateEnumDeclaration(node: EnumDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, members: readonly EnumMember[]): EnumDeclaration;
8489        /**
8490         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8491         */
8492        createModuleDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined, flags?: NodeFlags): ModuleDeclaration;
8493        /**
8494         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8495         */
8496        updateModuleDeclaration(node: ModuleDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined): ModuleDeclaration;
8497        /**
8498         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8499         */
8500        createImportEqualsDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: string | Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration;
8501        /**
8502         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8503         */
8504        updateImportEqualsDeclaration(node: ImportEqualsDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration;
8505        /**
8506         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8507         */
8508        createImportDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause?: AssertClause): ImportDeclaration;
8509        /**
8510         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8511         */
8512        updateImportDeclaration(node: ImportDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration;
8513        /**
8514         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8515         */
8516        createExportAssignment(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isExportEquals: boolean | undefined, expression: Expression): ExportAssignment;
8517        /**
8518         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8519         */
8520        updateExportAssignment(node: ExportAssignment, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, expression: Expression): ExportAssignment;
8521        /**
8522         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8523         */
8524        createExportDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, exportClause: NamedExportBindings | undefined, moduleSpecifier?: Expression, assertClause?: AssertClause): ExportDeclaration;
8525        /**
8526         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8527         */
8528        updateExportDeclaration(node: ExportDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, exportClause: NamedExportBindings | undefined, moduleSpecifier: Expression | undefined, assertClause: AssertClause | undefined): ExportDeclaration;
8529    }
8530}
8531declare namespace ts {
8532    namespace ArkTSLinter_1_0 {
8533        namespace Common {
8534            interface AutofixInfo {
8535                problemID: string;
8536                start: number;
8537                end: number;
8538            }
8539            interface CommandLineOptions {
8540                strictMode?: boolean;
8541                ideMode?: boolean;
8542                logTscErrors?: boolean;
8543                warningsAsErrors: boolean;
8544                parsedConfigFile?: ParsedCommandLine;
8545                inputFiles: string[];
8546                autofixInfo?: AutofixInfo[];
8547            }
8548            interface LintOptions {
8549                cmdOptions: CommandLineOptions;
8550                tsProgram?: Program;
8551                [key: string]: any;
8552            }
8553        }
8554    }
8555}
8556declare namespace ts {
8557    namespace ArkTSLinter_1_0 {
8558        const cookBookMsg: string[];
8559        const cookBookTag: string[];
8560    }
8561}
8562declare namespace ts {
8563    namespace ArkTSLinter_1_0 {
8564        namespace DiagnosticCheckerNamespace {
8565            interface DiagnosticChecker {
8566                checkDiagnosticMessage(msgText: string | ts.DiagnosticMessageChain): boolean;
8567            }
8568        }
8569    }
8570}
8571declare namespace ts {
8572    namespace ArkTSLinter_1_0 {
8573        import DiagnosticChecker = DiagnosticCheckerNamespace.DiagnosticChecker;
8574        namespace LibraryTypeCallDiagnosticCheckerNamespace {
8575            const TYPE_0_IS_NOT_ASSIGNABLE_TO_TYPE_1_ERROR_CODE = 2322;
8576            const TYPE_UNKNOWN_IS_NOT_ASSIGNABLE_TO_TYPE_1_RE: RegExp;
8577            const TYPE_NULL_IS_NOT_ASSIGNABLE_TO_TYPE_1_RE: RegExp;
8578            const TYPE_UNDEFINED_IS_NOT_ASSIGNABLE_TO_TYPE_1_RE: RegExp;
8579            const ARGUMENT_OF_TYPE_0_IS_NOT_ASSIGNABLE_TO_PARAMETER_OF_TYPE_1_ERROR_CODE = 2345;
8580            const ARGUMENT_OF_TYPE_NULL_IS_NOT_ASSIGNABLE_TO_PARAMETER_OF_TYPE_1_RE: RegExp;
8581            const ARGUMENT_OF_TYPE_UNDEFINED_IS_NOT_ASSIGNABLE_TO_PARAMETER_OF_TYPE_1_RE: RegExp;
8582            const NO_OVERLOAD_MATCHES_THIS_CALL_ERROR_CODE = 2769;
8583            class LibraryTypeCallDiagnosticChecker implements DiagnosticChecker {
8584                inLibCall: boolean;
8585                diagnosticMessages: Array<ts.DiagnosticMessageChain> | undefined;
8586                filteredDiagnosticMessages: DiagnosticMessageChain[];
8587                constructor(filteredDiagnosticMessages: DiagnosticMessageChain[]);
8588                configure(inLibCall: boolean, diagnosticMessages: Array<ts.DiagnosticMessageChain>): void;
8589                checkMessageText(msg: string): boolean;
8590                checkMessageChain(chain: ts.DiagnosticMessageChain): boolean;
8591                checkFilteredDiagnosticMessages(msgText: ts.DiagnosticMessageChain | string): boolean;
8592                checkDiagnosticMessage(msgText: string | ts.DiagnosticMessageChain): boolean;
8593            }
8594        }
8595    }
8596}
8597declare namespace ts {
8598    namespace ArkTSLinter_1_0 {
8599        namespace Utils {
8600            import AutofixInfo = Common.AutofixInfo;
8601            const PROPERTY_HAS_NO_INITIALIZER_ERROR_CODE = 2564;
8602            const NON_INITIALIZABLE_PROPERTY_DECORATORS: string[];
8603            const NON_INITIALIZABLE_PROPERTY_ClASS_DECORATORS: string[];
8604            const LIMITED_STANDARD_UTILITY_TYPES: string[];
8605            const ALLOWED_STD_SYMBOL_API: string[];
8606            enum ProblemSeverity {
8607                WARNING = 1,
8608                ERROR = 2
8609            }
8610            const ARKTS_IGNORE_DIRS: string[];
8611            const ARKTS_IGNORE_FILES: string[];
8612            function setTypeChecker(tsTypeChecker: TypeChecker): void;
8613            function clearTypeChecker(): void;
8614            function setTestMode(tsTestMode: boolean): void;
8615            function getStartPos(nodeOrComment: Node | CommentRange): number;
8616            function getEndPos(nodeOrComment: Node | CommentRange): number;
8617            function isAssignmentOperator(tsBinOp: BinaryOperatorToken): boolean;
8618            function isTypedArray(tsType: TypeNode | undefined): boolean;
8619            function isType(tsType: TypeNode | undefined, checkType: string): boolean;
8620            function entityNameToString(name: EntityName): string;
8621            function isNumberType(tsType: Type): boolean;
8622            function isBooleanType(tsType: Type): boolean;
8623            function isStringLikeType(tsType: Type): boolean;
8624            function isStringType(type: Type): boolean;
8625            function isPrimitiveEnumType(type: Type, primitiveType: TypeFlags): boolean;
8626            function isPrimitiveEnumMemberType(type: Type, primitiveType: TypeFlags): boolean;
8627            function unwrapParenthesizedType(tsType: TypeNode): TypeNode;
8628            function findParentIf(asExpr: AsExpression): IfStatement | null;
8629            function isDestructuringAssignmentLHS(tsExpr: ArrayLiteralExpression | ObjectLiteralExpression): boolean;
8630            function isEnumType(tsType: Type): boolean;
8631            function isEnumMemberType(tsType: Type): boolean;
8632            function isObjectLiteralType(tsType: Type): boolean;
8633            function isNumberLikeType(tsType: Type): boolean;
8634            function hasModifier(tsModifiers: readonly Modifier[] | undefined, tsModifierKind: number): boolean;
8635            function unwrapParenthesized(tsExpr: Expression): Expression;
8636            function followIfAliased(sym: Symbol): Symbol;
8637            function trueSymbolAtLocation(node: Node): Symbol | undefined;
8638            function clearTrueSymbolAtLocationCache(): void;
8639            function isTypeDeclSyntaxKind(kind: SyntaxKind): boolean;
8640            function symbolHasDuplicateName(symbol: Symbol, tsDeclKind: SyntaxKind): boolean;
8641            function isReferenceType(tsType: Type): boolean;
8642            function isPrimitiveType(type: Type): boolean;
8643            function isTypeSymbol(symbol: Symbol | undefined): boolean;
8644            function isGenericArrayType(tsType: Type): tsType is TypeReference;
8645            function isDerivedFrom(tsType: Type, checkType: CheckType): tsType is TypeReference;
8646            function isTypeReference(tsType: Type): tsType is TypeReference;
8647            function isNullType(tsTypeNode: TypeNode): boolean;
8648            function isThisOrSuperExpr(tsExpr: Expression): boolean;
8649            function isPrototypeSymbol(symbol: Symbol | undefined): boolean;
8650            function isFunctionSymbol(symbol: Symbol | undefined): boolean;
8651            function isInterfaceType(tsType: Type | undefined): boolean;
8652            function isAnyType(tsType: Type): tsType is TypeReference;
8653            function isUnknownType(tsType: Type): boolean;
8654            function isUnsupportedType(tsType: Type): boolean;
8655            function isUnsupportedUnionType(tsType: Type): boolean;
8656            function isFunctionOrMethod(tsSymbol: Symbol | undefined): boolean;
8657            function isMethodAssignment(tsSymbol: Symbol | undefined): boolean;
8658            function getDeclaration(tsSymbol: ts.Symbol | undefined): ts.Declaration | undefined;
8659            function isValidEnumMemberInit(tsExpr: Expression): boolean;
8660            function isCompileTimeExpression(tsExpr: Expression): boolean;
8661            function isConst(tsNode: Node): boolean;
8662            function isNumberConstantValue(tsExpr: EnumMember | PropertyAccessExpression | ElementAccessExpression | NumericLiteral): boolean;
8663            function isIntegerConstantValue(tsExpr: EnumMember | PropertyAccessExpression | ElementAccessExpression | NumericLiteral): boolean;
8664            function isStringConstantValue(tsExpr: EnumMember | PropertyAccessExpression | ElementAccessExpression): boolean;
8665            function relatedByInheritanceOrIdentical(typeA: Type, typeB: Type): boolean;
8666            function needToDeduceStructuralIdentity(typeFrom: Type, typeTo: Type, allowPromotion?: boolean): boolean;
8667            function hasPredecessor(node: Node, predicate: (node: Node) => boolean): boolean;
8668            function processParentTypes(parentTypes: NodeArray<ExpressionWithTypeArguments>, typeB: Type, processInterfaces: boolean): boolean;
8669            function processParentTypesCheck(parentTypes: NodeArray<ExpressionWithTypeArguments>, checkType: CheckType): boolean;
8670            function isObjectType(tsType: Type): boolean;
8671            function logTscDiagnostic(diagnostics: readonly Diagnostic[], log: (message: any, ...args: any[]) => void): void;
8672            function encodeProblemInfo(problem: ProblemInfo): string;
8673            function decodeAutofixInfo(info: string): AutofixInfo;
8674            function isCallToFunctionWithOmittedReturnType(tsExpr: Expression): boolean;
8675            function validateObjectLiteralType(type: Type | undefined): boolean;
8676            function isStructDeclarationKind(kind: SyntaxKind): boolean;
8677            function isStructDeclaration(node: Node): boolean;
8678            function isStructObjectInitializer(objectLiteral: ObjectLiteralExpression): boolean;
8679            function hasMethods(type: Type): boolean;
8680            function isExpressionAssignableToType(lhsType: ts.Type | undefined, rhsExpr: ts.Expression): boolean;
8681            function isLiteralType(type: Type): boolean;
8682            function validateFields(type: Type, objectLiteral: ObjectLiteralExpression): boolean;
8683            function isSupportedType(typeNode: TypeNode): boolean;
8684            function isStruct(symbol: Symbol): boolean;
8685            enum CheckType {
8686                Array = 0,
8687                String = "String",
8688                Set = "Set",
8689                Map = "Map",
8690                Error = "Error"
8691            }
8692            const ES_OBJECT = "ESObject";
8693            const LIMITED_STD_GLOBAL_FUNC: string[];
8694            const LIMITED_STD_OBJECT_API: string[];
8695            const LIMITED_STD_REFLECT_API: string[];
8696            const LIMITED_STD_PROXYHANDLER_API: string[];
8697            const ARKUI_DECORATORS: string[];
8698            const FUNCTION_HAS_NO_RETURN_ERROR_CODE = 2366;
8699            const NON_RETURN_FUNCTION_DECORATORS: string[];
8700            const STANDARD_LIBRARIES: string[];
8701            const TYPED_ARRAYS: string[];
8702            function getParentSymbolName(symbol: Symbol): string | undefined;
8703            function isGlobalSymbol(symbol: Symbol): boolean;
8704            function isSymbolAPI(symbol: Symbol): boolean;
8705            function isStdSymbol(symbol: ts.Symbol): boolean;
8706            function isSymbolIterator(symbol: ts.Symbol): boolean;
8707            function isDefaultImport(importSpec: ImportSpecifier): boolean;
8708            function hasAccessModifier(decl: Declaration): boolean;
8709            function getModifier(modifiers: readonly Modifier[] | undefined, modifierKind: SyntaxKind): Modifier | undefined;
8710            function getAccessModifier(modifiers: readonly Modifier[] | undefined): Modifier | undefined;
8711            function isStdRecordType(type: Type): boolean;
8712            function isStdPartialType(type: Type): boolean;
8713            function isStdRequiredType(type: Type): boolean;
8714            function isStdReadonlyType(type: Type): boolean;
8715            function isLibraryType(type: Type): boolean;
8716            function hasLibraryType(node: Node): boolean;
8717            function isLibrarySymbol(sym: Symbol | undefined): boolean;
8718            function pathContainsDirectory(targetPath: string, dir: string): boolean;
8719            function getScriptKind(srcFile: SourceFile): ScriptKind;
8720            function isStdLibraryType(type: Type): boolean;
8721            function isStdLibrarySymbol(sym: Symbol | undefined): boolean;
8722            function isIntrinsicObjectType(type: Type): boolean;
8723            function isDynamicType(type: Type | undefined): boolean | undefined;
8724            function isDynamicLiteralInitializer(expr: Expression): boolean;
8725            function isEsObjectType(typeNode: TypeNode): boolean;
8726            function isInsideBlock(node: ts.Node): boolean;
8727            function isEsObjectPossiblyAllowed(typeRef: ts.TypeReferenceNode): boolean;
8728            function isValueAssignableToESObject(node: ts.Node): boolean;
8729            function getVariableDeclarationTypeNode(node: Node): TypeNode | undefined;
8730            function getSymbolDeclarationTypeNode(sym: ts.Symbol): ts.TypeNode | undefined;
8731            function hasEsObjectType(node: Node): boolean;
8732            function symbolHasEsObjectType(sym: ts.Symbol): boolean;
8733            function isEsObjectSymbol(sym: Symbol): boolean;
8734            function isAnonymousType(type: Type): boolean;
8735            function getSymbolOfCallExpression(callExpr: CallExpression): Symbol | undefined;
8736            function typeIsRecursive(topType: Type, type?: Type | undefined): boolean;
8737        }
8738    }
8739}
8740declare namespace ts {
8741    namespace ArkTSLinter_1_0 {
8742        namespace Problems {
8743            enum FaultID {
8744                AnyType = 0,
8745                SymbolType = 1,
8746                ObjectLiteralNoContextType = 2,
8747                ArrayLiteralNoContextType = 3,
8748                ComputedPropertyName = 4,
8749                LiteralAsPropertyName = 5,
8750                TypeQuery = 6,
8751                RegexLiteral = 7,
8752                IsOperator = 8,
8753                DestructuringParameter = 9,
8754                YieldExpression = 10,
8755                InterfaceMerging = 11,
8756                EnumMerging = 12,
8757                InterfaceExtendsClass = 13,
8758                IndexMember = 14,
8759                WithStatement = 15,
8760                ThrowStatement = 16,
8761                IndexedAccessType = 17,
8762                UnknownType = 18,
8763                ForInStatement = 19,
8764                InOperator = 20,
8765                ImportFromPath = 21,
8766                FunctionExpression = 22,
8767                IntersectionType = 23,
8768                ObjectTypeLiteral = 24,
8769                CommaOperator = 25,
8770                LimitedReturnTypeInference = 26,
8771                LambdaWithTypeParameters = 27,
8772                ClassExpression = 28,
8773                DestructuringAssignment = 29,
8774                DestructuringDeclaration = 30,
8775                VarDeclaration = 31,
8776                CatchWithUnsupportedType = 32,
8777                DeleteOperator = 33,
8778                DeclWithDuplicateName = 34,
8779                UnaryArithmNotNumber = 35,
8780                ConstructorType = 36,
8781                ConstructorIface = 37,
8782                ConstructorFuncs = 38,
8783                CallSignature = 39,
8784                TypeAssertion = 40,
8785                PrivateIdentifier = 41,
8786                LocalFunction = 42,
8787                ConditionalType = 43,
8788                MappedType = 44,
8789                NamespaceAsObject = 45,
8790                ClassAsObject = 46,
8791                NonDeclarationInNamespace = 47,
8792                GeneratorFunction = 48,
8793                FunctionContainsThis = 49,
8794                PropertyAccessByIndex = 50,
8795                JsxElement = 51,
8796                EnumMemberNonConstInit = 52,
8797                ImplementsClass = 53,
8798                NoUndefinedPropAccess = 54,
8799                MultipleStaticBlocks = 55,
8800                ThisType = 56,
8801                IntefaceExtendDifProps = 57,
8802                StructuralIdentity = 58,
8803                DefaultImport = 59,
8804                ExportAssignment = 60,
8805                ImportAssignment = 61,
8806                GenericCallNoTypeArgs = 62,
8807                ParameterProperties = 63,
8808                InstanceofUnsupported = 64,
8809                ShorthandAmbientModuleDecl = 65,
8810                WildcardsInModuleName = 66,
8811                UMDModuleDefinition = 67,
8812                NewTarget = 68,
8813                DefiniteAssignment = 69,
8814                Prototype = 70,
8815                GlobalThis = 71,
8816                UtilityType = 72,
8817                PropertyDeclOnFunction = 73,
8818                FunctionApplyBindCall = 74,
8819                ConstAssertion = 75,
8820                ImportAssertion = 76,
8821                SpreadOperator = 77,
8822                LimitedStdLibApi = 78,
8823                ErrorSuppression = 79,
8824                StrictDiagnostic = 80,
8825                UnsupportedDecorators = 81,
8826                ImportAfterStatement = 82,
8827                EsObjectType = 83,
8828                LAST_ID = 84
8829            }
8830            class FaultAttributs {
8831                migratable?: boolean;
8832                warning?: boolean;
8833                cookBookRef: string;
8834            }
8835            const faultsAttrs: FaultAttributs[];
8836        }
8837    }
8838}
8839declare namespace ts {
8840    namespace ArkTSLinter_1_0 {
8841        namespace Autofixer {
8842            import AutofixInfo = Common.AutofixInfo;
8843            import FaultID = Problems.FaultID;
8844            const AUTOFIX_ALL: AutofixInfo;
8845            const autofixInfo: AutofixInfo[];
8846            function shouldAutofix(node: Node, faultID: FaultID): boolean;
8847            interface Autofix {
8848                replacementText: string;
8849                start: number;
8850                end: number;
8851            }
8852            function fixLiteralAsPropertyName(node: Node): Autofix[] | undefined;
8853            function fixPropertyAccessByIndex(node: Node): Autofix[] | undefined;
8854            function fixFunctionExpression(funcExpr: FunctionExpression, params?: NodeArray<ParameterDeclaration>, retType?: TypeNode | undefined): Autofix;
8855            function fixReturnType(funcLikeDecl: FunctionLikeDeclaration, typeNode: TypeNode): Autofix;
8856            function fixCtorParameterProperties(ctorDecl: ConstructorDeclaration, paramTypes: TypeNode[]): Autofix[] | undefined;
8857        }
8858    }
8859}
8860declare namespace ts {
8861    namespace ArkTSLinter_1_0 {
8862        import FaultID = Problems.FaultID;
8863        class LinterConfig {
8864            static nodeDesc: string[];
8865            static tsSyntaxKindNames: string[];
8866            static initStatic(): void;
8867            static terminalTokens: Set<SyntaxKind>;
8868            static incrementOnlyTokens: ESMap<SyntaxKind, FaultID>;
8869        }
8870    }
8871}
8872declare namespace ts {
8873    namespace ArkTSLinter_1_0 {
8874        import Autofix = Autofixer.Autofix;
8875        import LibraryTypeCallDiagnosticChecker = LibraryTypeCallDiagnosticCheckerNamespace.LibraryTypeCallDiagnosticChecker;
8876        interface ProblemInfo {
8877            line: number;
8878            column: number;
8879            start: number;
8880            end: number;
8881            type: string;
8882            severity: number;
8883            problem: string;
8884            suggest: string;
8885            rule: string;
8886            ruleTag: number;
8887            autofixable: boolean;
8888            autofix?: Autofix[];
8889        }
8890        class TypeScriptLinter {
8891            private sourceFile;
8892            private tscStrictDiagnostics?;
8893            static ideMode: boolean;
8894            static strictMode: boolean;
8895            static logTscErrors: boolean;
8896            static warningsAsErrors: boolean;
8897            static lintEtsOnly: boolean;
8898            static totalVisitedNodes: number;
8899            static nodeCounters: number[];
8900            static lineCounters: number[];
8901            static totalErrorLines: number;
8902            static errorLineNumbersString: string;
8903            static totalWarningLines: number;
8904            static warningLineNumbersString: string;
8905            static reportDiagnostics: boolean;
8906            static problemsInfos: ProblemInfo[];
8907            static filteredDiagnosticMessages: DiagnosticMessageChain[];
8908            static initGlobals(): void;
8909            static initStatic(): void;
8910            static tsTypeChecker: TypeChecker;
8911            currentErrorLine: number;
8912            currentWarningLine: number;
8913            staticBlocks: Set<string>;
8914            libraryTypeCallDiagnosticChecker: LibraryTypeCallDiagnosticChecker;
8915            skipArkTSStaticBlocksCheck: boolean;
8916            constructor(sourceFile: SourceFile, tsProgram: Program, tscStrictDiagnostics?: Map<Diagnostic[]> | undefined);
8917            static clearTsTypeChecker(): void;
8918            readonly handlersMap: ESMap<SyntaxKind, (node: Node) => void>;
8919            incrementCounters(node: Node | CommentRange, faultId: number, autofixable?: boolean, autofix?: Autofix[]): void;
8920            visitTSNode(node: Node): void;
8921            private countInterfaceExtendsDifferentPropertyTypes;
8922            private countDeclarationsWithDuplicateName;
8923            private countClassMembersWithDuplicateName;
8924            private functionContainsThis;
8925            private isPrototypePropertyAccess;
8926            private interfaceInheritanceLint;
8927            private lintForInterfaceExtendsDifferentPorpertyTypes;
8928            private handleObjectLiteralExpression;
8929            private handleArrayLiteralExpression;
8930            private handleParameter;
8931            private handleEnumDeclaration;
8932            private handleInterfaceDeclaration;
8933            private handleThrowStatement;
8934            private handleForStatement;
8935            private handleForInStatement;
8936            private handleForOfStatement;
8937            private handleImportDeclaration;
8938            private handlePropertyAccessExpression;
8939            private handlePropertyAssignmentOrDeclaration;
8940            private filterOutDecoratorsDiagnostics;
8941            private checkInRange;
8942            private filterStrictDiagnostics;
8943            private handleFunctionExpression;
8944            private handleArrowFunction;
8945            private handleClassExpression;
8946            private handleFunctionDeclaration;
8947            private handleMissingReturnType;
8948            private hasLimitedTypeInferenceFromReturnExpr;
8949            private handlePrefixUnaryExpression;
8950            private handleBinaryExpression;
8951            private handleVariableDeclarationList;
8952            private handleVariableDeclaration;
8953            private handleEsObjectDelaration;
8954            private handleEsObjectAssignment;
8955            private handleCatchClause;
8956            private handleClassDeclaration;
8957            private handleModuleDeclaration;
8958            private handleTypeAliasDeclaration;
8959            private handleImportClause;
8960            private handleImportSpecifier;
8961            private handleNamespaceImport;
8962            private handleTypeAssertionExpression;
8963            private handleMethodDeclaration;
8964            private handleIdentifier;
8965            private isAllowedClassValueContext;
8966            private handleRestrictedValues;
8967            private identiferUseInValueContext;
8968            private isEnumPropAccess;
8969            private handleElementAccessExpression;
8970            private handleEnumMember;
8971            private handleExportAssignment;
8972            private handleCallExpression;
8973            private handleImportCall;
8974            private handleRequireCall;
8975            private handleGenericCallWithNoTypeArgs;
8976            private static listApplyBindCallApis;
8977            private handleFunctionApplyBindPropCall;
8978            private handleStructIdentAndUndefinedInArgs;
8979            private static LimitedApis;
8980            private handleStdlibAPICall;
8981            private findNonFilteringRangesFunctionCalls;
8982            private handleLibraryTypeCall;
8983            private handleNewExpression;
8984            private handleAsExpression;
8985            private handleTypeReference;
8986            private handleMetaProperty;
8987            private handleStructDeclaration;
8988            private handleSpreadOp;
8989            private handleConstructSignature;
8990            private handleComments;
8991            private handleExpressionWithTypeArguments;
8992            private handleComputedPropertyName;
8993            private checkErrorSuppressingAnnotation;
8994            private handleDecorators;
8995            private handleGetAccessor;
8996            private handleSetAccessor;
8997            private handleDeclarationInferredType;
8998            private handleDefiniteAssignmentAssertion;
8999            private validatedTypesSet;
9000            private checkAnyOrUnknownChildNode;
9001            private handleInferredObjectreference;
9002            private validateDeclInferredType;
9003            private handleClassStaticBlockDeclaration;
9004            lint(): void;
9005        }
9006    }
9007}
9008declare namespace ts {
9009    namespace ArkTSLinter_1_0 {
9010        class TSCCompiledProgram {
9011            private diagnosticsExtractor;
9012            private wasStrict;
9013            constructor(program: ArkTSProgram, reverseStrictBuilderProgram: ArkTSProgram);
9014            getOriginalProgram(): Program;
9015            getStrictProgram(): Program;
9016            getStrictBuilderProgram(): BuilderProgram;
9017            getNonStrictBuilderProgram(): BuilderProgram;
9018            getStrictDiagnostics(fileName: string): Diagnostic[];
9019            doAllGetDiagnostics(): void;
9020        }
9021    }
9022}
9023declare namespace ts {
9024    namespace ArkTSLinter_1_0 {
9025        interface ArkTSProgram {
9026            builderProgram: BuilderProgram;
9027            wasStrict: boolean;
9028        }
9029        function translateDiag(srcFile: SourceFile, problemInfo: ProblemInfo): Diagnostic;
9030        function runArkTSLinter(tsBuilderProgram: ArkTSProgram, reverseStrictBuilderProgram: ArkTSProgram, srcFile?: SourceFile, buildInfoWriteFile?: WriteFileCallback): Diagnostic[];
9031    }
9032}
9033declare namespace ts {
9034    namespace ArkTSLinter_1_1 {
9035        namespace Common {
9036            interface AutofixInfo {
9037                problemID: string;
9038                start: number;
9039                end: number;
9040            }
9041            interface CommandLineOptions {
9042                strictMode?: boolean;
9043                ideMode?: boolean;
9044                logTscErrors?: boolean;
9045                warningsAsErrors: boolean;
9046                parsedConfigFile?: ParsedCommandLine;
9047                inputFiles: string[];
9048                autofixInfo?: AutofixInfo[];
9049            }
9050            interface LintOptions {
9051                cmdOptions: CommandLineOptions;
9052                tsProgram?: Program;
9053                [key: string]: any;
9054            }
9055            enum ProblemSeverity {
9056                WARNING = 1,
9057                ERROR = 2
9058            }
9059        }
9060    }
9061}
9062declare namespace ts {
9063    namespace ArkTSLinter_1_1 {
9064        const cookBookMsg: string[];
9065        const cookBookTag: string[];
9066    }
9067}
9068declare namespace ts {
9069    namespace ArkTSLinter_1_1 {
9070        namespace DiagnosticCheckerNamespace {
9071            interface DiagnosticChecker {
9072                checkDiagnosticMessage(msgText: string | ts.DiagnosticMessageChain): boolean;
9073            }
9074        }
9075    }
9076}
9077declare namespace ts {
9078    namespace ArkTSLinter_1_1 {
9079        import DiagnosticChecker = DiagnosticCheckerNamespace.DiagnosticChecker;
9080        namespace LibraryTypeCallDiagnosticCheckerNamespace {
9081            const TYPE_0_IS_NOT_ASSIGNABLE_TO_TYPE_1_ERROR_CODE = 2322;
9082            const TYPE_UNKNOWN_IS_NOT_ASSIGNABLE_TO_TYPE_1_RE: RegExp;
9083            const TYPE_NULL_IS_NOT_ASSIGNABLE_TO_TYPE_1_RE: RegExp;
9084            const TYPE_UNDEFINED_IS_NOT_ASSIGNABLE_TO_TYPE_1_RE: RegExp;
9085            const ARGUMENT_OF_TYPE_0_IS_NOT_ASSIGNABLE_TO_PARAMETER_OF_TYPE_1_ERROR_CODE = 2345;
9086            const ARGUMENT_OF_TYPE_NULL_IS_NOT_ASSIGNABLE_TO_PARAMETER_OF_TYPE_1_RE: RegExp;
9087            const ARGUMENT_OF_TYPE_UNDEFINED_IS_NOT_ASSIGNABLE_TO_PARAMETER_OF_TYPE_1_RE: RegExp;
9088            const NO_OVERLOAD_MATCHES_THIS_CALL_ERROR_CODE = 2769;
9089            class LibraryTypeCallDiagnosticChecker implements DiagnosticChecker {
9090                inLibCall: boolean;
9091                diagnosticMessages: Array<ts.DiagnosticMessageChain> | undefined;
9092                filteredDiagnosticMessages: DiagnosticMessageChain[];
9093                constructor(filteredDiagnosticMessages: DiagnosticMessageChain[]);
9094                configure(inLibCall: boolean, diagnosticMessages: Array<ts.DiagnosticMessageChain>): void;
9095                checkMessageText(msg: string): boolean;
9096                checkMessageChain(chain: ts.DiagnosticMessageChain): boolean;
9097                checkFilteredDiagnosticMessages(msgText: ts.DiagnosticMessageChain | string): boolean;
9098                checkDiagnosticMessage(msgText: string | ts.DiagnosticMessageChain): boolean;
9099            }
9100        }
9101    }
9102}
9103declare namespace ts {
9104    namespace ArkTSLinter_1_1 {
9105        namespace Problems {
9106            import ProblemSeverity = Common.ProblemSeverity;
9107            enum FaultID {
9108                AnyType = 0,
9109                SymbolType = 1,
9110                ObjectLiteralNoContextType = 2,
9111                ArrayLiteralNoContextType = 3,
9112                ComputedPropertyName = 4,
9113                LiteralAsPropertyName = 5,
9114                TypeQuery = 6,
9115                IsOperator = 7,
9116                DestructuringParameter = 8,
9117                YieldExpression = 9,
9118                InterfaceMerging = 10,
9119                EnumMerging = 11,
9120                InterfaceExtendsClass = 12,
9121                IndexMember = 13,
9122                WithStatement = 14,
9123                ThrowStatement = 15,
9124                IndexedAccessType = 16,
9125                UnknownType = 17,
9126                ForInStatement = 18,
9127                InOperator = 19,
9128                FunctionExpression = 20,
9129                IntersectionType = 21,
9130                ObjectTypeLiteral = 22,
9131                CommaOperator = 23,
9132                LimitedReturnTypeInference = 24,
9133                LambdaWithTypeParameters = 25,
9134                ClassExpression = 26,
9135                DestructuringAssignment = 27,
9136                DestructuringDeclaration = 28,
9137                VarDeclaration = 29,
9138                CatchWithUnsupportedType = 30,
9139                DeleteOperator = 31,
9140                DeclWithDuplicateName = 32,
9141                UnaryArithmNotNumber = 33,
9142                ConstructorType = 34,
9143                ConstructorIface = 35,
9144                ConstructorFuncs = 36,
9145                CallSignature = 37,
9146                TypeAssertion = 38,
9147                PrivateIdentifier = 39,
9148                LocalFunction = 40,
9149                ConditionalType = 41,
9150                MappedType = 42,
9151                NamespaceAsObject = 43,
9152                ClassAsObject = 44,
9153                NonDeclarationInNamespace = 45,
9154                GeneratorFunction = 46,
9155                FunctionContainsThis = 47,
9156                PropertyAccessByIndex = 48,
9157                JsxElement = 49,
9158                EnumMemberNonConstInit = 50,
9159                ImplementsClass = 51,
9160                MethodReassignment = 52,
9161                MultipleStaticBlocks = 53,
9162                ThisType = 54,
9163                IntefaceExtendDifProps = 55,
9164                StructuralIdentity = 56,
9165                DefaultImport = 57,
9166                ExportAssignment = 58,
9167                ImportAssignment = 59,
9168                GenericCallNoTypeArgs = 60,
9169                ParameterProperties = 61,
9170                InstanceofUnsupported = 62,
9171                ShorthandAmbientModuleDecl = 63,
9172                WildcardsInModuleName = 64,
9173                UMDModuleDefinition = 65,
9174                NewTarget = 66,
9175                DefiniteAssignment = 67,
9176                Prototype = 68,
9177                GlobalThis = 69,
9178                UtilityType = 70,
9179                PropertyDeclOnFunction = 71,
9180                FunctionApplyCall = 72,
9181                FunctionBind = 73,
9182                ConstAssertion = 74,
9183                ImportAssertion = 75,
9184                SpreadOperator = 76,
9185                LimitedStdLibApi = 77,
9186                ErrorSuppression = 78,
9187                StrictDiagnostic = 79,
9188                ImportAfterStatement = 80,
9189                EsObjectType = 81,
9190                LAST_ID = 82
9191            }
9192            class FaultAttributes {
9193                cookBookRef: number;
9194                migratable: boolean;
9195                severity: ProblemSeverity;
9196                constructor(cookBookRef: number, migratable?: boolean, severity?: ProblemSeverity);
9197            }
9198            const faultsAttrs: FaultAttributes[];
9199        }
9200    }
9201}
9202declare namespace ts {
9203    namespace ArkTSLinter_1_1 {
9204        import AutofixInfo = Common.AutofixInfo;
9205        namespace Utils {
9206            const PROPERTY_HAS_NO_INITIALIZER_ERROR_CODE = 2564;
9207            const NON_INITIALIZABLE_PROPERTY_DECORATORS: string[];
9208            const NON_INITIALIZABLE_PROPERTY_CLASS_DECORATORS: string[];
9209            const LIMITED_STANDARD_UTILITY_TYPES: string[];
9210            const ALLOWED_STD_SYMBOL_API: string[];
9211            const ARKTS_IGNORE_DIRS: string[];
9212            const ARKTS_IGNORE_FILES: string[];
9213            function setTypeChecker(tsTypeChecker: TypeChecker): void;
9214            function clearTypeChecker(): void;
9215            function setTestMode(tsTestMode: boolean): void;
9216            function getStartPos(nodeOrComment: Node | CommentRange): number;
9217            function getEndPos(nodeOrComment: Node | CommentRange): number;
9218            function getHighlightRange(nodeOrComment: Node | CommentRange, faultId: number): [number, number];
9219            function getVarDeclarationHighlightRange(nodeOrComment: Node | CommentRange): [number, number] | undefined;
9220            function getCatchWithUnsupportedTypeHighlightRange(nodeOrComment: Node | CommentRange): [number, number] | undefined;
9221            function getForInStatementHighlightRange(nodeOrComment: Node | CommentRange): [number, number] | undefined;
9222            function getWithStatementHighlightRange(nodeOrComment: Node | CommentRange): [number, number] | undefined;
9223            function getDeleteOperatorHighlightRange(nodeOrComment: Node | CommentRange): [number, number] | undefined;
9224            function getTypeQueryHighlightRange(nodeOrComment: Node | CommentRange): [number, number] | undefined;
9225            function getInstanceofUnsupportedHighlightRange(nodeOrComment: Node | CommentRange): [number, number] | undefined;
9226            function getConstAssertionHighlightRange(nodeOrComment: Node | CommentRange): [number, number] | undefined;
9227            function getLimitedReturnTypeInferenceHighlightRange(nodeOrComment: Node | CommentRange): [number, number] | undefined;
9228            function getLocalFunctionHighlightRange(nodeOrComment: Node | CommentRange): [number, number] | undefined;
9229            function getFunctionApplyCallHighlightRange(nodeOrComment: Node | CommentRange): [number, number] | undefined;
9230            function getDeclWithDuplicateNameHighlightRange(nodeOrComment: Node | CommentRange): [number, number] | undefined;
9231            function getObjectLiteralNoContextTypeHighlightRange(nodeOrComment: Node | CommentRange): [number, number] | undefined;
9232            function getClassExpressionHighlightRange(nodeOrComment: Node | CommentRange): [number, number] | undefined;
9233            function getKeywordHighlightRange(nodeOrComment: Node | CommentRange, keyword: string): [number, number];
9234            function isAssignmentOperator(tsBinOp: BinaryOperatorToken): boolean;
9235            function isType(tsType: TypeNode | undefined, checkType: string): boolean;
9236            function entityNameToString(name: EntityName): string;
9237            function isNumberLikeType(tsType: Type): boolean;
9238            function isBooleanLikeType(tsType: Type): boolean;
9239            function isStringLikeType(tsType: Type): boolean;
9240            function isStringType(tsType: ts.Type): boolean;
9241            function isPrimitiveEnumMemberType(type: Type, primitiveType: TypeFlags): boolean;
9242            function unwrapParenthesizedType(tsType: TypeNode): TypeNode;
9243            function findParentIf(asExpr: AsExpression): IfStatement | null;
9244            function isDestructuringAssignmentLHS(tsExpr: ArrayLiteralExpression | ObjectLiteralExpression): boolean;
9245            function isEnumType(tsType: ts.Type): boolean;
9246            function isEnum(tsSymbol: ts.Symbol): boolean;
9247            function isEnumMemberType(tsType: Type): boolean;
9248            function isObjectLiteralType(tsType: Type): boolean;
9249            function hasModifier(tsModifiers: readonly Modifier[] | undefined, tsModifierKind: number): boolean;
9250            function unwrapParenthesized(tsExpr: Expression): Expression;
9251            function followIfAliased(sym: Symbol): Symbol;
9252            function trueSymbolAtLocation(node: Node): Symbol | undefined;
9253            function clearTrueSymbolAtLocationCache(): void;
9254            function isTypeDeclSyntaxKind(kind: SyntaxKind): boolean;
9255            function symbolHasDuplicateName(symbol: Symbol, tsDeclKind: SyntaxKind): boolean;
9256            function isReferenceType(tsType: Type): boolean;
9257            function isPrimitiveType(type: Type): boolean;
9258            function isTypeSymbol(symbol: Symbol | undefined): boolean;
9259            function isGenericArrayType(tsType: Type): tsType is TypeReference;
9260            function isReadonlyArrayType(tsType: Type): boolean;
9261            function isTypedArray(tsType: ts.Type): boolean;
9262            function isArray(tsType: ts.Type): boolean;
9263            function isTuple(tsType: ts.Type): boolean;
9264            function isOrDerivedFrom(tsType: ts.Type, checkType: CheckType): boolean;
9265            function isTypeReference(tsType: Type): tsType is TypeReference;
9266            function isNullType(tsTypeNode: TypeNode): boolean;
9267            function isThisOrSuperExpr(tsExpr: Expression): boolean;
9268            function isPrototypeSymbol(symbol: Symbol | undefined): boolean;
9269            function isFunctionSymbol(symbol: Symbol | undefined): boolean;
9270            function isInterfaceType(tsType: Type | undefined): boolean;
9271            function isAnyType(tsType: Type): tsType is TypeReference;
9272            function isUnknownType(tsType: Type): boolean;
9273            function isUnsupportedType(tsType: Type): boolean;
9274            function isUnsupportedUnionType(tsType: Type): boolean;
9275            function isFunctionOrMethod(tsSymbol: Symbol | undefined): boolean;
9276            function isMethodAssignment(tsSymbol: Symbol | undefined): boolean;
9277            function getDeclaration(tsSymbol: ts.Symbol | undefined): ts.Declaration | undefined;
9278            function isValidEnumMemberInit(tsExpr: Expression): boolean;
9279            function isCompileTimeExpression(tsExpr: Expression): boolean;
9280            function isConst(tsNode: Node): boolean;
9281            function isNumberConstantValue(tsExpr: EnumMember | PropertyAccessExpression | ElementAccessExpression | NumericLiteral): boolean;
9282            function isIntegerConstantValue(tsExpr: EnumMember | PropertyAccessExpression | ElementAccessExpression | NumericLiteral): boolean;
9283            function isStringConstantValue(tsExpr: EnumMember | PropertyAccessExpression | ElementAccessExpression): boolean;
9284            function relatedByInheritanceOrIdentical(typeA: Type, typeB: Type): boolean;
9285            function reduceReference(t: ts.Type): ts.Type;
9286            function needToDeduceStructuralIdentity(lhsType: Type, rhsType: Type, rhsExpr: Expression): boolean;
9287            function hasPredecessor(node: Node, predicate: (node: Node) => boolean): boolean;
9288            function processParentTypes(parentTypes: NodeArray<ExpressionWithTypeArguments>, typeB: Type, processInterfaces: boolean): boolean;
9289            function isObject(tsType: Type): boolean;
9290            function logTscDiagnostic(diagnostics: readonly Diagnostic[], log: (message: any, ...args: any[]) => void): void;
9291            function encodeProblemInfo(problem: ProblemInfo): string;
9292            function decodeAutofixInfo(info: string): AutofixInfo;
9293            function isCallToFunctionWithOmittedReturnType(tsExpr: Expression): boolean;
9294            function validateObjectLiteralType(type: Type | undefined): boolean;
9295            function isStructDeclarationKind(kind: SyntaxKind): boolean;
9296            function isStructDeclaration(node: Node): boolean;
9297            function isStructObjectInitializer(objectLiteral: ObjectLiteralExpression): boolean;
9298            function hasMethods(type: Type): boolean;
9299            function checkTypeSet(typeSet: ts.Type, predicate: CheckType): boolean;
9300            function getNonNullableType(t: ts.Type): ts.Type;
9301            function isObjectLiteralAssignable(lhsType: ts.Type | undefined, rhsExpr: ts.ObjectLiteralExpression): boolean;
9302            function isLiteralType(type: Type): boolean;
9303            function validateFields(objectType: Type, objectLiteral: ObjectLiteralExpression): boolean;
9304            function isSupportedType(typeNode: TypeNode): boolean;
9305            function isStruct(symbol: Symbol): boolean;
9306            type CheckType = ((t: Type) => boolean);
9307            const ES_OBJECT = "ESObject";
9308            const LIMITED_STD_GLOBAL_FUNC: string[];
9309            const LIMITED_STD_OBJECT_API: string[];
9310            const LIMITED_STD_REFLECT_API: string[];
9311            const LIMITED_STD_PROXYHANDLER_API: string[];
9312            const FUNCTION_HAS_NO_RETURN_ERROR_CODE = 2366;
9313            const NON_RETURN_FUNCTION_DECORATORS: string[];
9314            const STANDARD_LIBRARIES: string[];
9315            const TYPED_ARRAYS: string[];
9316            function getParentSymbolName(symbol: Symbol): string | undefined;
9317            function isGlobalSymbol(symbol: Symbol): boolean;
9318            function isSymbolAPI(symbol: Symbol): boolean;
9319            function isStdSymbol(symbol: ts.Symbol): boolean;
9320            function isSymbolIterator(symbol: ts.Symbol): boolean;
9321            function isDefaultImport(importSpec: ImportSpecifier): boolean;
9322            function hasAccessModifier(decl: Declaration): boolean;
9323            function getModifier(modifiers: readonly Modifier[] | undefined, modifierKind: SyntaxKind): Modifier | undefined;
9324            function getAccessModifier(modifiers: readonly Modifier[] | undefined): Modifier | undefined;
9325            function isStdRecordType(type: Type): boolean;
9326            function isStdMapType(type: Type): boolean;
9327            function isStdErrorType(type: ts.Type): boolean;
9328            function isStdPartialType(type: Type): boolean;
9329            function isStdRequiredType(type: Type): boolean;
9330            function isStdReadonlyType(type: Type): boolean;
9331            function isLibraryType(type: Type): boolean;
9332            function hasLibraryType(node: Node): boolean;
9333            function isLibrarySymbol(sym: Symbol | undefined): boolean;
9334            function pathContainsDirectory(targetPath: string, dir: string): boolean;
9335            function getScriptKind(srcFile: SourceFile): ScriptKind;
9336            function isStdLibraryType(type: Type): boolean;
9337            function isStdLibrarySymbol(sym: Symbol | undefined): boolean;
9338            function isIntrinsicObjectType(type: Type): boolean;
9339            function isDynamicType(type: Type | undefined): boolean | undefined;
9340            function isObjectType(type: ts.Type): type is ts.ObjectType;
9341            function isAnonymous(type: ts.Type): boolean;
9342            function isDynamicLiteralInitializer(expr: Expression): boolean;
9343            function isEsObjectType(typeNode: ts.TypeNode | undefined): boolean;
9344            function isInsideBlock(node: ts.Node): boolean;
9345            function isEsObjectPossiblyAllowed(typeRef: ts.TypeReferenceNode): boolean;
9346            function isValueAssignableToESObject(node: ts.Node): boolean;
9347            function getVariableDeclarationTypeNode(node: Node): TypeNode | undefined;
9348            function getSymbolDeclarationTypeNode(sym: ts.Symbol): ts.TypeNode | undefined;
9349            function hasEsObjectType(node: Node): boolean;
9350            function symbolHasEsObjectType(sym: ts.Symbol): boolean;
9351            function isEsObjectSymbol(sym: Symbol): boolean;
9352            function isAnonymousType(type: Type): boolean;
9353            function getSymbolOfCallExpression(callExpr: CallExpression): Symbol | undefined;
9354            function typeIsRecursive(topType: Type, type?: Type | undefined): boolean;
9355            function getTypeOrTypeConstraintAtLocation(expr: ts.Expression): ts.Type;
9356            function isStdBigIntType(type: ts.Type): boolean;
9357            function isStdNumberType(type: ts.Type): boolean;
9358            function isStdBooleanType(type: ts.Type): boolean;
9359            function isEnumStringLiteral(expr: ts.Expression): boolean;
9360            function isValidComputedPropertyName(computedProperty: ComputedPropertyName, isRecordObjectInitializer?: boolean): boolean;
9361        }
9362    }
9363}
9364declare namespace ts {
9365    namespace ArkTSLinter_1_1 {
9366        namespace Autofixer {
9367            import AutofixInfo = Common.AutofixInfo;
9368            import FaultID = Problems.FaultID;
9369            const AUTOFIX_ALL: AutofixInfo;
9370            const autofixInfo: AutofixInfo[];
9371            function shouldAutofix(node: Node, faultID: FaultID): boolean;
9372            interface Autofix {
9373                replacementText: string;
9374                start: number;
9375                end: number;
9376            }
9377            function fixLiteralAsPropertyName(node: Node): Autofix[] | undefined;
9378            function fixPropertyAccessByIndex(node: Node): Autofix[] | undefined;
9379            function fixFunctionExpression(funcExpr: FunctionExpression, params?: NodeArray<ParameterDeclaration>, retType?: TypeNode | undefined): Autofix;
9380            function fixReturnType(funcLikeDecl: FunctionLikeDeclaration, typeNode: TypeNode): Autofix;
9381            function fixCtorParameterProperties(ctorDecl: ConstructorDeclaration, paramTypes: TypeNode[]): Autofix[] | undefined;
9382        }
9383    }
9384}
9385declare namespace ts {
9386    namespace ArkTSLinter_1_1 {
9387        import FaultID = Problems.FaultID;
9388        class LinterConfig {
9389            static nodeDesc: string[];
9390            static tsSyntaxKindNames: string[];
9391            static initStatic(): void;
9392            static terminalTokens: Set<SyntaxKind>;
9393            static incrementOnlyTokens: ESMap<SyntaxKind, FaultID>;
9394        }
9395    }
9396}
9397declare namespace ts {
9398    namespace ArkTSLinter_1_1 {
9399        import Autofix = Autofixer.Autofix;
9400        import LibraryTypeCallDiagnosticChecker = LibraryTypeCallDiagnosticCheckerNamespace.LibraryTypeCallDiagnosticChecker;
9401        interface ProblemInfo {
9402            line: number;
9403            column: number;
9404            start: number;
9405            end: number;
9406            type: string;
9407            severity: number;
9408            problem: string;
9409            suggest: string;
9410            rule: string;
9411            ruleTag: number;
9412            autofixable: boolean;
9413            autofix?: Autofix[];
9414        }
9415        class TypeScriptLinter {
9416            private sourceFile;
9417            private tscStrictDiagnostics?;
9418            static ideMode: boolean;
9419            static strictMode: boolean;
9420            static logTscErrors: boolean;
9421            static warningsAsErrors: boolean;
9422            static lintEtsOnly: boolean;
9423            static totalVisitedNodes: number;
9424            static nodeCounters: number[];
9425            static lineCounters: number[];
9426            static totalErrorLines: number;
9427            static errorLineNumbersString: string;
9428            static totalWarningLines: number;
9429            static warningLineNumbersString: string;
9430            static reportDiagnostics: boolean;
9431            static problemsInfos: ProblemInfo[];
9432            static filteredDiagnosticMessages: DiagnosticMessageChain[];
9433            static initGlobals(): void;
9434            static initStatic(): void;
9435            static tsTypeChecker: TypeChecker;
9436            currentErrorLine: number;
9437            currentWarningLine: number;
9438            staticBlocks: Set<string>;
9439            libraryTypeCallDiagnosticChecker: LibraryTypeCallDiagnosticChecker;
9440            skipArkTSStaticBlocksCheck: boolean;
9441            constructor(sourceFile: SourceFile, tsProgram: Program, tscStrictDiagnostics?: Map<Diagnostic[]> | undefined);
9442            static clearTsTypeChecker(): void;
9443            readonly handlersMap: ESMap<SyntaxKind, (node: Node) => void>;
9444            incrementCounters(node: Node | CommentRange, faultId: number, autofixable?: boolean, autofix?: Autofix[]): void;
9445            private forEachNodeInSubtree;
9446            private visitSourceFile;
9447            private countInterfaceExtendsDifferentPropertyTypes;
9448            private countDeclarationsWithDuplicateName;
9449            private countClassMembersWithDuplicateName;
9450            private static scopeContainsThis;
9451            private isPrototypePropertyAccess;
9452            private interfaceInheritanceLint;
9453            private lintForInterfaceExtendsDifferentPorpertyTypes;
9454            private handleObjectLiteralExpression;
9455            private handleArrayLiteralExpression;
9456            private handleParameter;
9457            private handleEnumDeclaration;
9458            private handleInterfaceDeclaration;
9459            private handleThrowStatement;
9460            private handleForStatement;
9461            private handleForInStatement;
9462            private handleForOfStatement;
9463            private handleImportDeclaration;
9464            private handlePropertyAccessExpression;
9465            private handlePropertyDeclaration;
9466            private handlePropertyAssignment;
9467            private handlePropertySignature;
9468            private filterOutDecoratorsDiagnostics;
9469            private checkInRange;
9470            private filterStrictDiagnostics;
9471            private static isClassLikeOrIface;
9472            private handleFunctionExpression;
9473            private handleArrowFunction;
9474            private handleFunctionDeclaration;
9475            private handleMissingReturnType;
9476            private hasLimitedTypeInferenceFromReturnExpr;
9477            private isValidTypeForUnaryArithmeticOperator;
9478            private handlePrefixUnaryExpression;
9479            private handleBinaryExpression;
9480            private handleVariableDeclarationList;
9481            private handleVariableDeclaration;
9482            private handleEsObjectDelaration;
9483            private handleEsObjectAssignment;
9484            private handleCatchClause;
9485            private handleClassDeclaration;
9486            private handleModuleDeclaration;
9487            private handleTypeAliasDeclaration;
9488            private handleImportClause;
9489            private handleImportSpecifier;
9490            private handleNamespaceImport;
9491            private handleTypeAssertionExpression;
9492            private handleMethodDeclaration;
9493            private handleMethodSignature;
9494            private handleIdentifier;
9495            private isAllowedClassValueContext;
9496            private handleRestrictedValues;
9497            private identiferUseInValueContext;
9498            private isEnumPropAccess;
9499            private isElementAcessAllowed;
9500            private handleElementAccessExpression;
9501            private handleEnumMember;
9502            private handleExportAssignment;
9503            private handleCallExpression;
9504            private handleEtsComponentExpression;
9505            private handleImportCall;
9506            private handleRequireCall;
9507            private handleGenericCallWithNoTypeArgs;
9508            private static readonly listFunctionApplyCallApis;
9509            private static readonly listFunctionBindApis;
9510            private handleFunctionApplyBindPropCall;
9511            private handleStructIdentAndUndefinedInArgs;
9512            private static LimitedApis;
9513            private handleStdlibAPICall;
9514            private findNonFilteringRangesFunctionCalls;
9515            private handleLibraryTypeCall;
9516            private handleNewExpression;
9517            private handleAsExpression;
9518            private handleTypeReference;
9519            private handleMetaProperty;
9520            private handleSpreadOp;
9521            private handleConstructSignature;
9522            private handleExpressionWithTypeArguments;
9523            private handleComputedPropertyName;
9524            private handleGetAccessor;
9525            private handleSetAccessor;
9526            private handleDeclarationInferredType;
9527            private handleDefiniteAssignmentAssertion;
9528            private validatedTypesSet;
9529            private checkAnyOrUnknownChildNode;
9530            private handleInferredObjectreference;
9531            private validateDeclInferredType;
9532            private processNoCheckEntry;
9533            private reportThisKeywordsInScope;
9534            private handleCommentDirectives;
9535            private handleClassStaticBlockDeclaration;
9536            lint(): void;
9537        }
9538    }
9539}
9540declare namespace ts {
9541    namespace ArkTSLinter_1_1 {
9542        class TSCCompiledProgram {
9543            private diagnosticsExtractor;
9544            private wasStrict;
9545            constructor(program: ArkTSProgram, reverseStrictBuilderProgram: ArkTSProgram);
9546            getOriginalProgram(): Program;
9547            getStrictProgram(): Program;
9548            getStrictBuilderProgram(): BuilderProgram;
9549            getNonStrictBuilderProgram(): BuilderProgram;
9550            getStrictDiagnostics(fileName: string): Diagnostic[];
9551            doAllGetDiagnostics(): void;
9552        }
9553    }
9554}
9555declare namespace ts {
9556    namespace ArkTSLinter_1_1 {
9557        interface ArkTSProgram {
9558            builderProgram: BuilderProgram;
9559            wasStrict: boolean;
9560        }
9561        function translateDiag(srcFile: SourceFile, problemInfo: ProblemInfo): Diagnostic;
9562        function runArkTSLinter(tsBuilderProgram: ArkTSProgram, reverseStrictBuilderProgram: ArkTSProgram, srcFile?: SourceFile, buildInfoWriteFile?: WriteFileCallback): Diagnostic[];
9563    }
9564}
9565
9566export = ts;