• 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        LazyKeyword = 156,
265        UndefinedKeyword = 157,
266        UniqueKeyword = 158,
267        UnknownKeyword = 159,
268        FromKeyword = 160,
269        GlobalKeyword = 161,
270        BigIntKeyword = 162,
271        OverrideKeyword = 163,
272        OfKeyword = 164,
273        QualifiedName = 165,
274        ComputedPropertyName = 166,
275        TypeParameter = 167,
276        Parameter = 168,
277        Decorator = 169,
278        PropertySignature = 170,
279        PropertyDeclaration = 171,
280        MethodSignature = 172,
281        MethodDeclaration = 173,
282        ClassStaticBlockDeclaration = 174,
283        Constructor = 175,
284        GetAccessor = 176,
285        SetAccessor = 177,
286        CallSignature = 178,
287        ConstructSignature = 179,
288        IndexSignature = 180,
289        TypePredicate = 181,
290        TypeReference = 182,
291        FunctionType = 183,
292        ConstructorType = 184,
293        TypeQuery = 185,
294        TypeLiteral = 186,
295        ArrayType = 187,
296        TupleType = 188,
297        OptionalType = 189,
298        RestType = 190,
299        UnionType = 191,
300        IntersectionType = 192,
301        ConditionalType = 193,
302        InferType = 194,
303        ParenthesizedType = 195,
304        ThisType = 196,
305        TypeOperator = 197,
306        IndexedAccessType = 198,
307        MappedType = 199,
308        LiteralType = 200,
309        NamedTupleMember = 201,
310        TemplateLiteralType = 202,
311        TemplateLiteralTypeSpan = 203,
312        ImportType = 204,
313        ObjectBindingPattern = 205,
314        ArrayBindingPattern = 206,
315        BindingElement = 207,
316        ArrayLiteralExpression = 208,
317        ObjectLiteralExpression = 209,
318        PropertyAccessExpression = 210,
319        ElementAccessExpression = 211,
320        CallExpression = 212,
321        NewExpression = 213,
322        TaggedTemplateExpression = 214,
323        TypeAssertionExpression = 215,
324        ParenthesizedExpression = 216,
325        FunctionExpression = 217,
326        ArrowFunction = 218,
327        EtsComponentExpression = 219,
328        DeleteExpression = 220,
329        TypeOfExpression = 221,
330        VoidExpression = 222,
331        AwaitExpression = 223,
332        PrefixUnaryExpression = 224,
333        PostfixUnaryExpression = 225,
334        BinaryExpression = 226,
335        ConditionalExpression = 227,
336        TemplateExpression = 228,
337        YieldExpression = 229,
338        SpreadElement = 230,
339        ClassExpression = 231,
340        OmittedExpression = 232,
341        ExpressionWithTypeArguments = 233,
342        AsExpression = 234,
343        NonNullExpression = 235,
344        MetaProperty = 236,
345        SyntheticExpression = 237,
346        SatisfiesExpression = 238,
347        TemplateSpan = 239,
348        SemicolonClassElement = 240,
349        Block = 241,
350        EmptyStatement = 242,
351        VariableStatement = 243,
352        ExpressionStatement = 244,
353        IfStatement = 245,
354        DoStatement = 246,
355        WhileStatement = 247,
356        ForStatement = 248,
357        ForInStatement = 249,
358        ForOfStatement = 250,
359        ContinueStatement = 251,
360        BreakStatement = 252,
361        ReturnStatement = 253,
362        WithStatement = 254,
363        SwitchStatement = 255,
364        LabeledStatement = 256,
365        ThrowStatement = 257,
366        TryStatement = 258,
367        DebuggerStatement = 259,
368        VariableDeclaration = 260,
369        VariableDeclarationList = 261,
370        FunctionDeclaration = 262,
371        ClassDeclaration = 263,
372        StructDeclaration = 264,
373        InterfaceDeclaration = 265,
374        TypeAliasDeclaration = 266,
375        EnumDeclaration = 267,
376        ModuleDeclaration = 268,
377        ModuleBlock = 269,
378        CaseBlock = 270,
379        NamespaceExportDeclaration = 271,
380        ImportEqualsDeclaration = 272,
381        ImportDeclaration = 273,
382        ImportClause = 274,
383        NamespaceImport = 275,
384        NamedImports = 276,
385        ImportSpecifier = 277,
386        ExportAssignment = 278,
387        ExportDeclaration = 279,
388        NamedExports = 280,
389        NamespaceExport = 281,
390        ExportSpecifier = 282,
391        MissingDeclaration = 283,
392        ExternalModuleReference = 284,
393        JsxElement = 285,
394        JsxSelfClosingElement = 286,
395        JsxOpeningElement = 287,
396        JsxClosingElement = 288,
397        JsxFragment = 289,
398        JsxOpeningFragment = 290,
399        JsxClosingFragment = 291,
400        JsxAttribute = 292,
401        JsxAttributes = 293,
402        JsxSpreadAttribute = 294,
403        JsxExpression = 295,
404        CaseClause = 296,
405        DefaultClause = 297,
406        HeritageClause = 298,
407        CatchClause = 299,
408        AssertClause = 300,
409        AssertEntry = 301,
410        ImportTypeAssertionContainer = 302,
411        PropertyAssignment = 303,
412        ShorthandPropertyAssignment = 304,
413        SpreadAssignment = 305,
414        EnumMember = 306,
415        UnparsedPrologue = 307,
416        UnparsedPrepend = 308,
417        UnparsedText = 309,
418        UnparsedInternalText = 310,
419        UnparsedSyntheticReference = 311,
420        SourceFile = 312,
421        Bundle = 313,
422        UnparsedSource = 314,
423        InputFiles = 315,
424        JSDocTypeExpression = 316,
425        JSDocNameReference = 317,
426        JSDocMemberName = 318,
427        JSDocAllType = 319,
428        JSDocUnknownType = 320,
429        JSDocNullableType = 321,
430        JSDocNonNullableType = 322,
431        JSDocOptionalType = 323,
432        JSDocFunctionType = 324,
433        JSDocVariadicType = 325,
434        JSDocNamepathType = 326,
435        JSDoc = 327,
436        /** @deprecated Use SyntaxKind.JSDoc */
437        JSDocComment = 327,
438        JSDocText = 328,
439        JSDocTypeLiteral = 329,
440        JSDocSignature = 330,
441        JSDocLink = 331,
442        JSDocLinkCode = 332,
443        JSDocLinkPlain = 333,
444        JSDocTag = 334,
445        JSDocAugmentsTag = 335,
446        JSDocImplementsTag = 336,
447        JSDocAuthorTag = 337,
448        JSDocDeprecatedTag = 338,
449        JSDocClassTag = 339,
450        JSDocPublicTag = 340,
451        JSDocPrivateTag = 341,
452        JSDocProtectedTag = 342,
453        JSDocReadonlyTag = 343,
454        JSDocOverrideTag = 344,
455        JSDocCallbackTag = 345,
456        JSDocEnumTag = 346,
457        JSDocParameterTag = 347,
458        JSDocReturnTag = 348,
459        JSDocThisTag = 349,
460        JSDocTypeTag = 350,
461        JSDocTemplateTag = 351,
462        JSDocTypedefTag = 352,
463        JSDocSeeTag = 353,
464        JSDocPropertyTag = 354,
465        SyntaxList = 355,
466        NotEmittedStatement = 356,
467        PartiallyEmittedExpression = 357,
468        CommaListExpression = 358,
469        MergeDeclarationMarker = 359,
470        EndOfDeclarationMarker = 360,
471        SyntheticReferenceExpression = 361,
472        Count = 362,
473        FirstAssignment = 63,
474        LastAssignment = 78,
475        FirstCompoundAssignment = 64,
476        LastCompoundAssignment = 78,
477        FirstReservedWord = 81,
478        LastReservedWord = 117,
479        FirstKeyword = 81,
480        LastKeyword = 164,
481        FirstFutureReservedWord = 118,
482        LastFutureReservedWord = 126,
483        FirstTypeNode = 181,
484        LastTypeNode = 204,
485        FirstPunctuation = 18,
486        LastPunctuation = 78,
487        FirstToken = 0,
488        LastToken = 164,
489        FirstTriviaToken = 2,
490        LastTriviaToken = 7,
491        FirstLiteralToken = 8,
492        LastLiteralToken = 14,
493        FirstTemplateToken = 14,
494        LastTemplateToken = 17,
495        FirstBinaryOperator = 29,
496        LastBinaryOperator = 78,
497        FirstStatement = 243,
498        LastStatement = 259,
499        FirstNode = 165,
500        FirstJSDocNode = 316,
501        LastJSDocNode = 354,
502        FirstJSDocTagNode = 334,
503        LastJSDocTagNode = 354,
504    }
505    export type TriviaSyntaxKind = SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia | SyntaxKind.NewLineTrivia | SyntaxKind.WhitespaceTrivia | SyntaxKind.ShebangTrivia | SyntaxKind.ConflictMarkerTrivia;
506    export type LiteralSyntaxKind = SyntaxKind.NumericLiteral | SyntaxKind.BigIntLiteral | SyntaxKind.StringLiteral | SyntaxKind.JsxText | SyntaxKind.JsxTextAllWhiteSpaces | SyntaxKind.RegularExpressionLiteral | SyntaxKind.NoSubstitutionTemplateLiteral;
507    export type PseudoLiteralSyntaxKind = SyntaxKind.TemplateHead | SyntaxKind.TemplateMiddle | SyntaxKind.TemplateTail;
508    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;
509    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.LazyKeyword | SyntaxKind.TypeOfKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VarKeyword | SyntaxKind.VoidKeyword | SyntaxKind.WhileKeyword | SyntaxKind.WithKeyword | SyntaxKind.YieldKeyword;
510    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;
511    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;
512    export type TokenSyntaxKind = SyntaxKind.Unknown | SyntaxKind.EndOfFileToken | TriviaSyntaxKind | LiteralSyntaxKind | PseudoLiteralSyntaxKind | PunctuationSyntaxKind | SyntaxKind.Identifier | KeywordSyntaxKind;
513    export type JsxTokenSyntaxKind = SyntaxKind.LessThanSlashToken | SyntaxKind.EndOfFileToken | SyntaxKind.ConflictMarkerTrivia | SyntaxKind.JsxText | SyntaxKind.JsxTextAllWhiteSpaces | SyntaxKind.OpenBraceToken | SyntaxKind.LessThanToken;
514    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;
515    export enum NodeFlags {
516        None = 0,
517        Let = 1,
518        Const = 2,
519        NestedNamespace = 4,
520        Synthesized = 8,
521        Namespace = 16,
522        OptionalChain = 32,
523        ExportContext = 64,
524        ContainsThis = 128,
525        HasImplicitReturn = 256,
526        HasExplicitReturn = 512,
527        GlobalAugmentation = 1024,
528        HasAsyncFunctions = 2048,
529        DisallowInContext = 4096,
530        YieldContext = 8192,
531        DecoratorContext = 16384,
532        AwaitContext = 32768,
533        DisallowConditionalTypesContext = 65536,
534        ThisNodeHasError = 131072,
535        JavaScriptFile = 262144,
536        ThisNodeOrAnySubNodesHasError = 524288,
537        HasAggregatedChildData = 1048576,
538        JSDoc = 8388608,
539        JsonFile = 67108864,
540        EtsContext = 1073741824,
541        BlockScoped = 3,
542        ReachabilityCheckFlags = 768,
543        ReachabilityAndEmitFlags = 2816,
544        ContextFlags = 1124462592,
545        TypeExcludesFlags = 40960,
546    }
547    export enum EtsFlags {
548        None = 0,
549        StructContext = 2,
550        EtsExtendComponentsContext = 4,
551        EtsStylesComponentsContext = 8,
552        EtsBuildContext = 16,
553        EtsBuilderContext = 32,
554        EtsStateStylesContext = 64,
555        EtsComponentsContext = 128,
556        EtsNewExpressionContext = 256,
557        UICallbackContext = 512,
558        SyntaxComponentContext = 1024
559    }
560    export enum ModifierFlags {
561        None = 0,
562        Export = 1,
563        Ambient = 2,
564        Public = 4,
565        Private = 8,
566        Protected = 16,
567        Static = 32,
568        Readonly = 64,
569        Accessor = 128,
570        Abstract = 256,
571        Async = 512,
572        Default = 1024,
573        Const = 2048,
574        HasComputedJSDocModifiers = 4096,
575        Deprecated = 8192,
576        Override = 16384,
577        In = 32768,
578        Out = 65536,
579        Decorator = 131072,
580        HasComputedFlags = 536870912,
581        AccessibilityModifier = 28,
582        ParameterPropertyModifier = 16476,
583        NonPublicAccessibilityModifier = 24,
584        TypeScriptModifier = 117086,
585        ExportDefault = 1025,
586        All = 258047,
587        Modifier = 126975
588    }
589    export enum JsxFlags {
590        None = 0,
591        /** An element from a named property of the JSX.IntrinsicElements interface */
592        IntrinsicNamedElement = 1,
593        /** An element inferred from the string index signature of the JSX.IntrinsicElements interface */
594        IntrinsicIndexedElement = 2,
595        IntrinsicElement = 3
596    }
597    export interface Node extends ReadonlyTextRange {
598        readonly kind: SyntaxKind;
599        readonly flags: NodeFlags;
600        readonly parent: Node;
601        symbol: Symbol;
602        locals?: SymbolTable;
603        skipCheck?: boolean;
604    }
605    export interface JSDocContainer {
606    }
607    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;
608    export type HasType = SignatureDeclaration | VariableDeclaration | ParameterDeclaration | PropertySignature | PropertyDeclaration | TypePredicateNode | ParenthesizedTypeNode | TypeOperatorNode | MappedTypeNode | AssertionExpression | TypeAliasDeclaration | JSDocTypeExpression | JSDocNonNullableType | JSDocNullableType | JSDocOptionalType | JSDocVariadicType;
609    export type HasTypeArguments = CallExpression | NewExpression | TaggedTemplateExpression | JsxOpeningElement | JsxSelfClosingElement;
610    export type HasInitializer = HasExpressionInitializer | ForStatement | ForInStatement | ForOfStatement | JsxAttribute;
611    export type HasExpressionInitializer = VariableDeclaration | ParameterDeclaration | BindingElement | PropertyDeclaration | PropertyAssignment | EnumMember;
612    export type HasDecorators = ParameterDeclaration | PropertyDeclaration | MethodDeclaration | GetAccessorDeclaration | SetAccessorDeclaration | ClassExpression | ClassDeclaration | StructDeclaration | FunctionDeclaration;
613    export type HasIllegalDecorators = PropertyAssignment | ShorthandPropertyAssignment | FunctionDeclaration | ConstructorDeclaration | IndexSignatureDeclaration | ClassStaticBlockDeclaration | MissingDeclaration | VariableStatement | InterfaceDeclaration | TypeAliasDeclaration | EnumDeclaration | ModuleDeclaration | ImportEqualsDeclaration | ImportDeclaration | NamespaceExportDeclaration | ExportDeclaration | ExportAssignment;
614    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;
615    export interface NodeArray<T extends Node> extends ReadonlyArray<T>, ReadonlyTextRange {
616        readonly hasTrailingComma: boolean;
617    }
618    export interface Token<TKind extends SyntaxKind> extends Node {
619        readonly kind: TKind;
620    }
621    export type EndOfFileToken = Token<SyntaxKind.EndOfFileToken> & JSDocContainer;
622    export interface PunctuationToken<TKind extends PunctuationSyntaxKind> extends Token<TKind> {
623    }
624    export type DotToken = PunctuationToken<SyntaxKind.DotToken>;
625    export type DotDotDotToken = PunctuationToken<SyntaxKind.DotDotDotToken>;
626    export type QuestionToken = PunctuationToken<SyntaxKind.QuestionToken>;
627    export type ExclamationToken = PunctuationToken<SyntaxKind.ExclamationToken>;
628    export type ColonToken = PunctuationToken<SyntaxKind.ColonToken>;
629    export type EqualsToken = PunctuationToken<SyntaxKind.EqualsToken>;
630    export type AsteriskToken = PunctuationToken<SyntaxKind.AsteriskToken>;
631    export type EqualsGreaterThanToken = PunctuationToken<SyntaxKind.EqualsGreaterThanToken>;
632    export type PlusToken = PunctuationToken<SyntaxKind.PlusToken>;
633    export type MinusToken = PunctuationToken<SyntaxKind.MinusToken>;
634    export type QuestionDotToken = PunctuationToken<SyntaxKind.QuestionDotToken>;
635    export interface KeywordToken<TKind extends KeywordSyntaxKind> extends Token<TKind> {
636    }
637    export type AssertsKeyword = KeywordToken<SyntaxKind.AssertsKeyword>;
638    export type AssertKeyword = KeywordToken<SyntaxKind.AssertKeyword>;
639    export type AwaitKeyword = KeywordToken<SyntaxKind.AwaitKeyword>;
640    /** @deprecated Use `AwaitKeyword` instead. */
641    export type AwaitKeywordToken = AwaitKeyword;
642    /** @deprecated Use `AssertsKeyword` instead. */
643    export type AssertsToken = AssertsKeyword;
644    export interface ModifierToken<TKind extends ModifierSyntaxKind> extends KeywordToken<TKind> {
645    }
646    export type AbstractKeyword = ModifierToken<SyntaxKind.AbstractKeyword>;
647    export type AccessorKeyword = ModifierToken<SyntaxKind.AccessorKeyword>;
648    export type AsyncKeyword = ModifierToken<SyntaxKind.AsyncKeyword>;
649    export type ConstKeyword = ModifierToken<SyntaxKind.ConstKeyword>;
650    export type DeclareKeyword = ModifierToken<SyntaxKind.DeclareKeyword>;
651    export type DefaultKeyword = ModifierToken<SyntaxKind.DefaultKeyword>;
652    export type ExportKeyword = ModifierToken<SyntaxKind.ExportKeyword>;
653    export type InKeyword = ModifierToken<SyntaxKind.InKeyword>;
654    export type PrivateKeyword = ModifierToken<SyntaxKind.PrivateKeyword>;
655    export type ProtectedKeyword = ModifierToken<SyntaxKind.ProtectedKeyword>;
656    export type PublicKeyword = ModifierToken<SyntaxKind.PublicKeyword>;
657    export type ReadonlyKeyword = ModifierToken<SyntaxKind.ReadonlyKeyword>;
658    export type OutKeyword = ModifierToken<SyntaxKind.OutKeyword>;
659    export type OverrideKeyword = ModifierToken<SyntaxKind.OverrideKeyword>;
660    export type StaticKeyword = ModifierToken<SyntaxKind.StaticKeyword>;
661    /** @deprecated Use `ReadonlyKeyword` instead. */
662    export type ReadonlyToken = ReadonlyKeyword;
663    export type Modifier = AbstractKeyword | AccessorKeyword | AsyncKeyword | ConstKeyword | DeclareKeyword | DefaultKeyword | ExportKeyword | InKeyword | PrivateKeyword | ProtectedKeyword | PublicKeyword | OutKeyword | OverrideKeyword | ReadonlyKeyword | StaticKeyword;
664    export type ModifierLike = Modifier | Decorator;
665    export type AccessibilityModifier = PublicKeyword | PrivateKeyword | ProtectedKeyword;
666    export type ParameterPropertyModifier = AccessibilityModifier | ReadonlyKeyword;
667    export type ClassMemberModifier = AccessibilityModifier | ReadonlyKeyword | StaticKeyword | AccessorKeyword;
668    export type ModifiersArray = NodeArray<Modifier>;
669    export enum GeneratedIdentifierFlags {
670        None = 0,
671        ReservedInNestedScopes = 8,
672        Optimistic = 16,
673        FileLevel = 32,
674        AllowNameSubstitution = 64
675    }
676    export interface Identifier extends PrimaryExpression, Declaration {
677        readonly kind: SyntaxKind.Identifier;
678        /**
679         * Prefer to use `id.unescapedText`. (Note: This is available only in services, not internally to the TypeScript compiler.)
680         * Text of identifier, but if the identifier begins with two underscores, this will begin with three.
681         */
682        readonly escapedText: __String;
683        readonly originalKeywordKind?: SyntaxKind;
684        isInJSDocNamespace?: boolean;
685    }
686    export interface TransientIdentifier extends Identifier {
687        resolvedSymbol: Symbol;
688    }
689    export interface QualifiedName extends Node {
690        readonly kind: SyntaxKind.QualifiedName;
691        readonly left: EntityName;
692        readonly right: Identifier;
693    }
694    export type EntityName = Identifier | QualifiedName;
695    export type PropertyName = Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | PrivateIdentifier;
696    export type MemberName = Identifier | PrivateIdentifier;
697    export type DeclarationName = Identifier | PrivateIdentifier | StringLiteralLike | NumericLiteral | ComputedPropertyName | ElementAccessExpression | BindingPattern | EntityNameExpression;
698    export interface Declaration extends Node {
699        _declarationBrand: any;
700    }
701    export interface NamedDeclaration extends Declaration {
702        readonly name?: DeclarationName;
703    }
704    export interface DeclarationStatement extends NamedDeclaration, Statement {
705        readonly name?: Identifier | StringLiteral | NumericLiteral;
706    }
707    export interface ComputedPropertyName extends Node {
708        readonly kind: SyntaxKind.ComputedPropertyName;
709        readonly parent: Declaration;
710        readonly expression: Expression;
711    }
712    export interface PrivateIdentifier extends PrimaryExpression {
713        readonly kind: SyntaxKind.PrivateIdentifier;
714        readonly escapedText: __String;
715    }
716    export interface Decorator extends Node {
717        readonly kind: SyntaxKind.Decorator;
718        readonly parent: NamedDeclaration;
719        readonly expression: LeftHandSideExpression;
720    }
721    export interface TypeParameterDeclaration extends NamedDeclaration {
722        readonly kind: SyntaxKind.TypeParameter;
723        readonly parent: DeclarationWithTypeParameterChildren | InferTypeNode;
724        readonly modifiers?: NodeArray<Modifier>;
725        readonly name: Identifier;
726        /** Note: Consider calling `getEffectiveConstraintOfTypeParameter` */
727        readonly constraint?: TypeNode;
728        readonly default?: TypeNode;
729        expression?: Expression;
730    }
731    export interface SignatureDeclarationBase extends NamedDeclaration, JSDocContainer {
732        readonly kind: SignatureDeclaration["kind"];
733        readonly name?: PropertyName;
734        readonly typeParameters?: NodeArray<TypeParameterDeclaration> | undefined;
735        readonly parameters: NodeArray<ParameterDeclaration>;
736        readonly type?: TypeNode | undefined;
737    }
738    export type SignatureDeclaration = CallSignatureDeclaration | ConstructSignatureDeclaration | MethodSignature | IndexSignatureDeclaration | FunctionTypeNode | ConstructorTypeNode | JSDocFunctionType | FunctionDeclaration | MethodDeclaration | ConstructorDeclaration | AccessorDeclaration | FunctionExpression | ArrowFunction;
739    export interface CallSignatureDeclaration extends SignatureDeclarationBase, TypeElement {
740        readonly kind: SyntaxKind.CallSignature;
741    }
742    export interface ConstructSignatureDeclaration extends SignatureDeclarationBase, TypeElement {
743        readonly kind: SyntaxKind.ConstructSignature;
744    }
745    export type BindingName = Identifier | BindingPattern;
746    export interface VariableDeclaration extends NamedDeclaration, JSDocContainer {
747        readonly kind: SyntaxKind.VariableDeclaration;
748        readonly parent: VariableDeclarationList | CatchClause;
749        readonly name: BindingName;
750        readonly exclamationToken?: ExclamationToken;
751        readonly type?: TypeNode;
752        readonly initializer?: Expression;
753    }
754    export interface VariableDeclarationList extends Node {
755        readonly kind: SyntaxKind.VariableDeclarationList;
756        readonly parent: VariableStatement | ForStatement | ForOfStatement | ForInStatement;
757        readonly declarations: NodeArray<VariableDeclaration>;
758    }
759    export interface ParameterDeclaration extends NamedDeclaration, JSDocContainer {
760        readonly kind: SyntaxKind.Parameter;
761        readonly parent: SignatureDeclaration;
762        readonly modifiers?: NodeArray<ModifierLike>;
763        readonly dotDotDotToken?: DotDotDotToken;
764        readonly name: BindingName;
765        readonly questionToken?: QuestionToken;
766        readonly type?: TypeNode;
767        readonly initializer?: Expression;
768    }
769    export interface BindingElement extends NamedDeclaration {
770        readonly kind: SyntaxKind.BindingElement;
771        readonly parent: BindingPattern;
772        readonly propertyName?: PropertyName;
773        readonly dotDotDotToken?: DotDotDotToken;
774        readonly name: BindingName;
775        readonly initializer?: Expression;
776    }
777    export interface PropertySignature extends TypeElement, JSDocContainer {
778        readonly kind: SyntaxKind.PropertySignature;
779        readonly modifiers?: NodeArray<Modifier>;
780        readonly name: PropertyName;
781        readonly questionToken?: QuestionToken;
782        readonly type?: TypeNode;
783    }
784    export interface PropertyDeclaration extends ClassElement, JSDocContainer {
785        readonly kind: SyntaxKind.PropertyDeclaration;
786        readonly parent: ClassLikeDeclaration;
787        readonly modifiers?: NodeArray<ModifierLike>;
788        readonly name: PropertyName;
789        readonly questionToken?: QuestionToken;
790        readonly exclamationToken?: ExclamationToken;
791        readonly type?: TypeNode;
792        readonly initializer?: Expression;
793    }
794    export interface AutoAccessorPropertyDeclaration extends PropertyDeclaration {
795        _autoAccessorBrand: any;
796    }
797    export interface ObjectLiteralElement extends NamedDeclaration {
798        _objectLiteralBrand: any;
799        readonly name?: PropertyName;
800    }
801    /** Unlike ObjectLiteralElement, excludes JSXAttribute and JSXSpreadAttribute. */
802    export type ObjectLiteralElementLike = PropertyAssignment | ShorthandPropertyAssignment | SpreadAssignment | MethodDeclaration | AccessorDeclaration;
803    export interface PropertyAssignment extends ObjectLiteralElement, JSDocContainer {
804        readonly kind: SyntaxKind.PropertyAssignment;
805        readonly parent: ObjectLiteralExpression;
806        readonly name: PropertyName;
807        readonly initializer: Expression;
808    }
809    export interface ShorthandPropertyAssignment extends ObjectLiteralElement, JSDocContainer {
810        readonly kind: SyntaxKind.ShorthandPropertyAssignment;
811        readonly parent: ObjectLiteralExpression;
812        readonly name: Identifier;
813        readonly equalsToken?: EqualsToken;
814        readonly objectAssignmentInitializer?: Expression;
815    }
816    export interface SpreadAssignment extends ObjectLiteralElement, JSDocContainer {
817        readonly kind: SyntaxKind.SpreadAssignment;
818        readonly parent: ObjectLiteralExpression;
819        readonly expression: Expression;
820    }
821    export type VariableLikeDeclaration = VariableDeclaration | ParameterDeclaration | BindingElement | PropertyDeclaration | PropertyAssignment | PropertySignature | JsxAttribute | ShorthandPropertyAssignment | EnumMember | JSDocPropertyTag | JSDocParameterTag;
822    export interface PropertyLikeDeclaration extends NamedDeclaration {
823        readonly name: PropertyName;
824    }
825    export interface ObjectBindingPattern extends Node {
826        readonly kind: SyntaxKind.ObjectBindingPattern;
827        readonly parent: VariableDeclaration | ParameterDeclaration | BindingElement;
828        readonly elements: NodeArray<BindingElement>;
829    }
830    export interface ArrayBindingPattern extends Node {
831        readonly kind: SyntaxKind.ArrayBindingPattern;
832        readonly parent: VariableDeclaration | ParameterDeclaration | BindingElement;
833        readonly elements: NodeArray<ArrayBindingElement>;
834    }
835    export type BindingPattern = ObjectBindingPattern | ArrayBindingPattern;
836    export type ArrayBindingElement = BindingElement | OmittedExpression;
837    /**
838     * Several node kinds share function-like features such as a signature,
839     * a name, and a body. These nodes should extend FunctionLikeDeclarationBase.
840     * Examples:
841     * - FunctionDeclaration
842     * - MethodDeclaration
843     * - AccessorDeclaration
844     */
845    export interface FunctionLikeDeclarationBase extends SignatureDeclarationBase {
846        _functionLikeDeclarationBrand: any;
847        readonly asteriskToken?: AsteriskToken | undefined;
848        readonly questionToken?: QuestionToken | undefined;
849        readonly exclamationToken?: ExclamationToken | undefined;
850        readonly body?: Block | Expression | undefined;
851    }
852    export type FunctionLikeDeclaration = FunctionDeclaration | MethodDeclaration | GetAccessorDeclaration | SetAccessorDeclaration | ConstructorDeclaration | FunctionExpression | ArrowFunction;
853    /** @deprecated Use SignatureDeclaration */
854    export type FunctionLike = SignatureDeclaration;
855    export interface FunctionDeclaration extends FunctionLikeDeclarationBase, DeclarationStatement {
856        readonly kind: SyntaxKind.FunctionDeclaration;
857        readonly modifiers?: NodeArray<Modifier>;
858        readonly name?: Identifier;
859        readonly body?: FunctionBody;
860    }
861    export interface MethodSignature extends SignatureDeclarationBase, TypeElement {
862        readonly kind: SyntaxKind.MethodSignature;
863        readonly parent: ObjectTypeDeclaration;
864        readonly modifiers?: NodeArray<Modifier>;
865        readonly name: PropertyName;
866    }
867    export interface MethodDeclaration extends FunctionLikeDeclarationBase, ClassElement, ObjectLiteralElement, JSDocContainer {
868        readonly kind: SyntaxKind.MethodDeclaration;
869        readonly parent: ClassLikeDeclaration | ObjectLiteralExpression;
870        readonly modifiers?: NodeArray<ModifierLike> | undefined;
871        readonly name: PropertyName;
872        readonly body?: FunctionBody | undefined;
873    }
874    export interface ConstructorDeclaration extends FunctionLikeDeclarationBase, ClassElement, JSDocContainer {
875        readonly kind: SyntaxKind.Constructor;
876        readonly parent: ClassLikeDeclaration;
877        readonly modifiers?: NodeArray<Modifier> | undefined;
878        readonly body?: FunctionBody | undefined;
879    }
880    /** For when we encounter a semicolon in a class declaration. ES6 allows these as class elements. */
881    export interface SemicolonClassElement extends ClassElement {
882        readonly kind: SyntaxKind.SemicolonClassElement;
883        readonly parent: ClassLikeDeclaration;
884    }
885    export interface GetAccessorDeclaration extends FunctionLikeDeclarationBase, ClassElement, TypeElement, ObjectLiteralElement, JSDocContainer {
886        readonly kind: SyntaxKind.GetAccessor;
887        readonly parent: ClassLikeDeclaration | ObjectLiteralExpression | TypeLiteralNode | InterfaceDeclaration;
888        readonly modifiers?: NodeArray<ModifierLike>;
889        readonly name: PropertyName;
890        readonly body?: FunctionBody;
891    }
892    export interface SetAccessorDeclaration extends FunctionLikeDeclarationBase, ClassElement, TypeElement, ObjectLiteralElement, JSDocContainer {
893        readonly kind: SyntaxKind.SetAccessor;
894        readonly parent: ClassLikeDeclaration | ObjectLiteralExpression | TypeLiteralNode | InterfaceDeclaration;
895        readonly modifiers?: NodeArray<ModifierLike>;
896        readonly name: PropertyName;
897        readonly body?: FunctionBody;
898    }
899    export type AccessorDeclaration = GetAccessorDeclaration | SetAccessorDeclaration;
900    export interface IndexSignatureDeclaration extends SignatureDeclarationBase, ClassElement, TypeElement {
901        readonly kind: SyntaxKind.IndexSignature;
902        readonly parent: ObjectTypeDeclaration;
903        readonly modifiers?: NodeArray<Modifier>;
904        readonly type: TypeNode;
905    }
906    export interface ClassStaticBlockDeclaration extends ClassElement, JSDocContainer {
907        readonly kind: SyntaxKind.ClassStaticBlockDeclaration;
908        readonly parent: ClassDeclaration | ClassExpression;
909        readonly body: Block;
910    }
911    export interface TypeNode extends Node {
912        _typeNodeBrand: any;
913    }
914    export interface KeywordTypeNode<TKind extends KeywordTypeSyntaxKind = KeywordTypeSyntaxKind> extends KeywordToken<TKind>, TypeNode {
915        readonly kind: TKind;
916    }
917    export interface ImportTypeAssertionContainer extends Node {
918        readonly kind: SyntaxKind.ImportTypeAssertionContainer;
919        readonly parent: ImportTypeNode;
920        readonly assertClause: AssertClause;
921        readonly multiLine?: boolean;
922    }
923    export interface ImportTypeNode extends NodeWithTypeArguments {
924        readonly kind: SyntaxKind.ImportType;
925        readonly isTypeOf: boolean;
926        readonly argument: TypeNode;
927        readonly assertions?: ImportTypeAssertionContainer;
928        readonly qualifier?: EntityName;
929    }
930    export interface ThisTypeNode extends TypeNode {
931        readonly kind: SyntaxKind.ThisType;
932    }
933    export type FunctionOrConstructorTypeNode = FunctionTypeNode | ConstructorTypeNode;
934    export interface FunctionOrConstructorTypeNodeBase extends TypeNode, SignatureDeclarationBase {
935        readonly kind: SyntaxKind.FunctionType | SyntaxKind.ConstructorType;
936        readonly type: TypeNode;
937    }
938    export interface FunctionTypeNode extends FunctionOrConstructorTypeNodeBase {
939        readonly kind: SyntaxKind.FunctionType;
940    }
941    export interface ConstructorTypeNode extends FunctionOrConstructorTypeNodeBase {
942        readonly kind: SyntaxKind.ConstructorType;
943        readonly modifiers?: NodeArray<Modifier>;
944    }
945    export interface NodeWithTypeArguments extends TypeNode {
946        readonly typeArguments?: NodeArray<TypeNode>;
947    }
948    export type TypeReferenceType = TypeReferenceNode | ExpressionWithTypeArguments;
949    export interface TypeReferenceNode extends NodeWithTypeArguments {
950        readonly kind: SyntaxKind.TypeReference;
951        readonly typeName: EntityName;
952    }
953    export interface TypePredicateNode extends TypeNode {
954        readonly kind: SyntaxKind.TypePredicate;
955        readonly parent: SignatureDeclaration | JSDocTypeExpression;
956        readonly assertsModifier?: AssertsKeyword;
957        readonly parameterName: Identifier | ThisTypeNode;
958        readonly type?: TypeNode;
959    }
960    export interface TypeQueryNode extends NodeWithTypeArguments {
961        readonly kind: SyntaxKind.TypeQuery;
962        readonly exprName: EntityName;
963    }
964    export interface TypeLiteralNode extends TypeNode, Declaration {
965        readonly kind: SyntaxKind.TypeLiteral;
966        readonly members: NodeArray<TypeElement>;
967    }
968    export interface ArrayTypeNode extends TypeNode {
969        readonly kind: SyntaxKind.ArrayType;
970        readonly elementType: TypeNode;
971    }
972    export interface TupleTypeNode extends TypeNode {
973        readonly kind: SyntaxKind.TupleType;
974        readonly elements: NodeArray<TypeNode | NamedTupleMember>;
975    }
976    export interface NamedTupleMember extends TypeNode, JSDocContainer, Declaration {
977        readonly kind: SyntaxKind.NamedTupleMember;
978        readonly dotDotDotToken?: Token<SyntaxKind.DotDotDotToken>;
979        readonly name: Identifier;
980        readonly questionToken?: Token<SyntaxKind.QuestionToken>;
981        readonly type: TypeNode;
982    }
983    export interface OptionalTypeNode extends TypeNode {
984        readonly kind: SyntaxKind.OptionalType;
985        readonly type: TypeNode;
986    }
987    export interface RestTypeNode extends TypeNode {
988        readonly kind: SyntaxKind.RestType;
989        readonly type: TypeNode;
990    }
991    export type UnionOrIntersectionTypeNode = UnionTypeNode | IntersectionTypeNode;
992    export interface UnionTypeNode extends TypeNode {
993        readonly kind: SyntaxKind.UnionType;
994        readonly types: NodeArray<TypeNode>;
995    }
996    export interface IntersectionTypeNode extends TypeNode {
997        readonly kind: SyntaxKind.IntersectionType;
998        readonly types: NodeArray<TypeNode>;
999    }
1000    export interface ConditionalTypeNode extends TypeNode {
1001        readonly kind: SyntaxKind.ConditionalType;
1002        readonly checkType: TypeNode;
1003        readonly extendsType: TypeNode;
1004        readonly trueType: TypeNode;
1005        readonly falseType: TypeNode;
1006    }
1007    export interface InferTypeNode extends TypeNode {
1008        readonly kind: SyntaxKind.InferType;
1009        readonly typeParameter: TypeParameterDeclaration;
1010    }
1011    export interface ParenthesizedTypeNode extends TypeNode {
1012        readonly kind: SyntaxKind.ParenthesizedType;
1013        readonly type: TypeNode;
1014    }
1015    export interface TypeOperatorNode extends TypeNode {
1016        readonly kind: SyntaxKind.TypeOperator;
1017        readonly operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword;
1018        readonly type: TypeNode;
1019    }
1020    export interface IndexedAccessTypeNode extends TypeNode {
1021        readonly kind: SyntaxKind.IndexedAccessType;
1022        readonly objectType: TypeNode;
1023        readonly indexType: TypeNode;
1024    }
1025    export interface MappedTypeNode extends TypeNode, Declaration {
1026        readonly kind: SyntaxKind.MappedType;
1027        readonly readonlyToken?: ReadonlyKeyword | PlusToken | MinusToken;
1028        readonly typeParameter: TypeParameterDeclaration;
1029        readonly nameType?: TypeNode;
1030        readonly questionToken?: QuestionToken | PlusToken | MinusToken;
1031        readonly type?: TypeNode;
1032        /** Used only to produce grammar errors */
1033        readonly members?: NodeArray<TypeElement>;
1034    }
1035    export interface LiteralTypeNode extends TypeNode {
1036        readonly kind: SyntaxKind.LiteralType;
1037        readonly literal: NullLiteral | BooleanLiteral | LiteralExpression | PrefixUnaryExpression;
1038    }
1039    export interface StringLiteral extends LiteralExpression, Declaration {
1040        readonly kind: SyntaxKind.StringLiteral;
1041    }
1042    export type StringLiteralLike = StringLiteral | NoSubstitutionTemplateLiteral;
1043    export type PropertyNameLiteral = Identifier | StringLiteralLike | NumericLiteral;
1044    export interface TemplateLiteralTypeNode extends TypeNode {
1045        kind: SyntaxKind.TemplateLiteralType;
1046        readonly head: TemplateHead;
1047        readonly templateSpans: NodeArray<TemplateLiteralTypeSpan>;
1048    }
1049    export interface TemplateLiteralTypeSpan extends TypeNode {
1050        readonly kind: SyntaxKind.TemplateLiteralTypeSpan;
1051        readonly parent: TemplateLiteralTypeNode;
1052        readonly type: TypeNode;
1053        readonly literal: TemplateMiddle | TemplateTail;
1054    }
1055    export interface Expression extends Node {
1056        _expressionBrand: any;
1057    }
1058    export interface OmittedExpression extends Expression {
1059        readonly kind: SyntaxKind.OmittedExpression;
1060    }
1061    export interface PartiallyEmittedExpression extends LeftHandSideExpression {
1062        readonly kind: SyntaxKind.PartiallyEmittedExpression;
1063        readonly expression: Expression;
1064    }
1065    export interface UnaryExpression extends Expression {
1066        _unaryExpressionBrand: any;
1067    }
1068    /** Deprecated, please use UpdateExpression */
1069    export type IncrementExpression = UpdateExpression;
1070    export interface UpdateExpression extends UnaryExpression {
1071        _updateExpressionBrand: any;
1072    }
1073    export type PrefixUnaryOperator = SyntaxKind.PlusPlusToken | SyntaxKind.MinusMinusToken | SyntaxKind.PlusToken | SyntaxKind.MinusToken | SyntaxKind.TildeToken | SyntaxKind.ExclamationToken;
1074    export interface PrefixUnaryExpression extends UpdateExpression {
1075        readonly kind: SyntaxKind.PrefixUnaryExpression;
1076        readonly operator: PrefixUnaryOperator;
1077        readonly operand: UnaryExpression;
1078    }
1079    export type PostfixUnaryOperator = SyntaxKind.PlusPlusToken | SyntaxKind.MinusMinusToken;
1080    export interface PostfixUnaryExpression extends UpdateExpression {
1081        readonly kind: SyntaxKind.PostfixUnaryExpression;
1082        readonly operand: LeftHandSideExpression;
1083        readonly operator: PostfixUnaryOperator;
1084    }
1085    export interface LeftHandSideExpression extends UpdateExpression {
1086        _leftHandSideExpressionBrand: any;
1087    }
1088    export interface MemberExpression extends LeftHandSideExpression {
1089        _memberExpressionBrand: any;
1090    }
1091    export interface PrimaryExpression extends MemberExpression {
1092        _primaryExpressionBrand: any;
1093    }
1094    export interface NullLiteral extends PrimaryExpression {
1095        readonly kind: SyntaxKind.NullKeyword;
1096    }
1097    export interface TrueLiteral extends PrimaryExpression {
1098        readonly kind: SyntaxKind.TrueKeyword;
1099    }
1100    export interface FalseLiteral extends PrimaryExpression {
1101        readonly kind: SyntaxKind.FalseKeyword;
1102    }
1103    export type BooleanLiteral = TrueLiteral | FalseLiteral;
1104    export interface ThisExpression extends PrimaryExpression {
1105        readonly kind: SyntaxKind.ThisKeyword;
1106    }
1107    export interface SuperExpression extends PrimaryExpression {
1108        readonly kind: SyntaxKind.SuperKeyword;
1109    }
1110    export interface ImportExpression extends PrimaryExpression {
1111        readonly kind: SyntaxKind.ImportKeyword;
1112    }
1113    export interface DeleteExpression extends UnaryExpression {
1114        readonly kind: SyntaxKind.DeleteExpression;
1115        readonly expression: UnaryExpression;
1116    }
1117    export interface TypeOfExpression extends UnaryExpression {
1118        readonly kind: SyntaxKind.TypeOfExpression;
1119        readonly expression: UnaryExpression;
1120    }
1121    export interface VoidExpression extends UnaryExpression {
1122        readonly kind: SyntaxKind.VoidExpression;
1123        readonly expression: UnaryExpression;
1124    }
1125    export interface AwaitExpression extends UnaryExpression {
1126        readonly kind: SyntaxKind.AwaitExpression;
1127        readonly expression: UnaryExpression;
1128    }
1129    export interface YieldExpression extends Expression {
1130        readonly kind: SyntaxKind.YieldExpression;
1131        readonly asteriskToken?: AsteriskToken;
1132        readonly expression?: Expression;
1133    }
1134    export interface SyntheticExpression extends Expression {
1135        readonly kind: SyntaxKind.SyntheticExpression;
1136        readonly isSpread: boolean;
1137        readonly type: Type;
1138        readonly tupleNameSource?: ParameterDeclaration | NamedTupleMember;
1139    }
1140    export type ExponentiationOperator = SyntaxKind.AsteriskAsteriskToken;
1141    export type MultiplicativeOperator = SyntaxKind.AsteriskToken | SyntaxKind.SlashToken | SyntaxKind.PercentToken;
1142    export type MultiplicativeOperatorOrHigher = ExponentiationOperator | MultiplicativeOperator;
1143    export type AdditiveOperator = SyntaxKind.PlusToken | SyntaxKind.MinusToken;
1144    export type AdditiveOperatorOrHigher = MultiplicativeOperatorOrHigher | AdditiveOperator;
1145    export type ShiftOperator = SyntaxKind.LessThanLessThanToken | SyntaxKind.GreaterThanGreaterThanToken | SyntaxKind.GreaterThanGreaterThanGreaterThanToken;
1146    export type ShiftOperatorOrHigher = AdditiveOperatorOrHigher | ShiftOperator;
1147    export type RelationalOperator = SyntaxKind.LessThanToken | SyntaxKind.LessThanEqualsToken | SyntaxKind.GreaterThanToken | SyntaxKind.GreaterThanEqualsToken | SyntaxKind.InstanceOfKeyword | SyntaxKind.InKeyword;
1148    export type RelationalOperatorOrHigher = ShiftOperatorOrHigher | RelationalOperator;
1149    export type EqualityOperator = SyntaxKind.EqualsEqualsToken | SyntaxKind.EqualsEqualsEqualsToken | SyntaxKind.ExclamationEqualsEqualsToken | SyntaxKind.ExclamationEqualsToken;
1150    export type EqualityOperatorOrHigher = RelationalOperatorOrHigher | EqualityOperator;
1151    export type BitwiseOperator = SyntaxKind.AmpersandToken | SyntaxKind.BarToken | SyntaxKind.CaretToken;
1152    export type BitwiseOperatorOrHigher = EqualityOperatorOrHigher | BitwiseOperator;
1153    export type LogicalOperator = SyntaxKind.AmpersandAmpersandToken | SyntaxKind.BarBarToken;
1154    export type LogicalOperatorOrHigher = BitwiseOperatorOrHigher | LogicalOperator;
1155    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;
1156    export type AssignmentOperator = SyntaxKind.EqualsToken | CompoundAssignmentOperator;
1157    export type AssignmentOperatorOrHigher = SyntaxKind.QuestionQuestionToken | LogicalOperatorOrHigher | AssignmentOperator;
1158    export type BinaryOperator = AssignmentOperatorOrHigher | SyntaxKind.CommaToken;
1159    export type LogicalOrCoalescingAssignmentOperator = SyntaxKind.AmpersandAmpersandEqualsToken | SyntaxKind.BarBarEqualsToken | SyntaxKind.QuestionQuestionEqualsToken;
1160    export type BinaryOperatorToken = Token<BinaryOperator>;
1161    export interface BinaryExpression extends Expression, Declaration {
1162        readonly kind: SyntaxKind.BinaryExpression;
1163        readonly left: Expression;
1164        readonly operatorToken: BinaryOperatorToken;
1165        readonly right: Expression;
1166    }
1167    export type AssignmentOperatorToken = Token<AssignmentOperator>;
1168    export interface AssignmentExpression<TOperator extends AssignmentOperatorToken> extends BinaryExpression {
1169        readonly left: LeftHandSideExpression;
1170        readonly operatorToken: TOperator;
1171    }
1172    export interface ObjectDestructuringAssignment extends AssignmentExpression<EqualsToken> {
1173        readonly left: ObjectLiteralExpression;
1174    }
1175    export interface ArrayDestructuringAssignment extends AssignmentExpression<EqualsToken> {
1176        readonly left: ArrayLiteralExpression;
1177    }
1178    export type DestructuringAssignment = ObjectDestructuringAssignment | ArrayDestructuringAssignment;
1179    export type BindingOrAssignmentElement = VariableDeclaration | ParameterDeclaration | ObjectBindingOrAssignmentElement | ArrayBindingOrAssignmentElement;
1180    export type ObjectBindingOrAssignmentElement = BindingElement | PropertyAssignment | ShorthandPropertyAssignment | SpreadAssignment;
1181    export type ArrayBindingOrAssignmentElement = BindingElement | OmittedExpression | SpreadElement | ArrayLiteralExpression | ObjectLiteralExpression | AssignmentExpression<EqualsToken> | Identifier | PropertyAccessExpression | ElementAccessExpression;
1182    export type BindingOrAssignmentElementRestIndicator = DotDotDotToken | SpreadElement | SpreadAssignment;
1183    export type BindingOrAssignmentElementTarget = BindingOrAssignmentPattern | Identifier | PropertyAccessExpression | ElementAccessExpression | OmittedExpression;
1184    export type ObjectBindingOrAssignmentPattern = ObjectBindingPattern | ObjectLiteralExpression;
1185    export type ArrayBindingOrAssignmentPattern = ArrayBindingPattern | ArrayLiteralExpression;
1186    export type AssignmentPattern = ObjectLiteralExpression | ArrayLiteralExpression;
1187    export type BindingOrAssignmentPattern = ObjectBindingOrAssignmentPattern | ArrayBindingOrAssignmentPattern;
1188    export interface ConditionalExpression extends Expression {
1189        readonly kind: SyntaxKind.ConditionalExpression;
1190        readonly condition: Expression;
1191        readonly questionToken: QuestionToken;
1192        readonly whenTrue: Expression;
1193        readonly colonToken: ColonToken;
1194        readonly whenFalse: Expression;
1195    }
1196    export type FunctionBody = Block;
1197    export type ConciseBody = FunctionBody | Expression;
1198    export interface FunctionExpression extends PrimaryExpression, FunctionLikeDeclarationBase, JSDocContainer {
1199        readonly kind: SyntaxKind.FunctionExpression;
1200        readonly modifiers?: NodeArray<Modifier>;
1201        readonly name?: Identifier;
1202        readonly body: FunctionBody;
1203    }
1204    export interface EtsComponentExpression extends PrimaryExpression, Declaration {
1205        readonly kind: SyntaxKind.EtsComponentExpression;
1206        readonly expression: LeftHandSideExpression;
1207        readonly typeArguments?: NodeArray<TypeNode>;
1208        readonly arguments: NodeArray<Expression>;
1209        readonly body?: Block;
1210    }
1211    export interface ArrowFunction extends Expression, FunctionLikeDeclarationBase, JSDocContainer {
1212        readonly kind: SyntaxKind.ArrowFunction;
1213        readonly modifiers?: NodeArray<Modifier>;
1214        readonly equalsGreaterThanToken: EqualsGreaterThanToken;
1215        readonly body: ConciseBody;
1216        readonly name: never;
1217    }
1218    export interface LiteralLikeNode extends Node {
1219        text: string;
1220        isUnterminated?: boolean;
1221        hasExtendedUnicodeEscape?: boolean;
1222    }
1223    export interface TemplateLiteralLikeNode extends LiteralLikeNode {
1224        rawText?: string;
1225    }
1226    export interface LiteralExpression extends LiteralLikeNode, PrimaryExpression {
1227        _literalExpressionBrand: any;
1228    }
1229    export interface RegularExpressionLiteral extends LiteralExpression {
1230        readonly kind: SyntaxKind.RegularExpressionLiteral;
1231    }
1232    export interface NoSubstitutionTemplateLiteral extends LiteralExpression, TemplateLiteralLikeNode, Declaration {
1233        readonly kind: SyntaxKind.NoSubstitutionTemplateLiteral;
1234    }
1235    export enum TokenFlags {
1236        None = 0,
1237        Scientific = 16,
1238        Octal = 32,
1239        HexSpecifier = 64,
1240        BinarySpecifier = 128,
1241        OctalSpecifier = 256,
1242    }
1243    export interface NumericLiteral extends LiteralExpression, Declaration {
1244        readonly kind: SyntaxKind.NumericLiteral;
1245    }
1246    export interface BigIntLiteral extends LiteralExpression {
1247        readonly kind: SyntaxKind.BigIntLiteral;
1248    }
1249    export type LiteralToken = NumericLiteral | BigIntLiteral | StringLiteral | JsxText | RegularExpressionLiteral | NoSubstitutionTemplateLiteral;
1250    export interface TemplateHead extends TemplateLiteralLikeNode {
1251        readonly kind: SyntaxKind.TemplateHead;
1252        readonly parent: TemplateExpression | TemplateLiteralTypeNode;
1253    }
1254    export interface TemplateMiddle extends TemplateLiteralLikeNode {
1255        readonly kind: SyntaxKind.TemplateMiddle;
1256        readonly parent: TemplateSpan | TemplateLiteralTypeSpan;
1257    }
1258    export interface TemplateTail extends TemplateLiteralLikeNode {
1259        readonly kind: SyntaxKind.TemplateTail;
1260        readonly parent: TemplateSpan | TemplateLiteralTypeSpan;
1261    }
1262    export type PseudoLiteralToken = TemplateHead | TemplateMiddle | TemplateTail;
1263    export type TemplateLiteralToken = NoSubstitutionTemplateLiteral | PseudoLiteralToken;
1264    export interface TemplateExpression extends PrimaryExpression {
1265        readonly kind: SyntaxKind.TemplateExpression;
1266        readonly head: TemplateHead;
1267        readonly templateSpans: NodeArray<TemplateSpan>;
1268    }
1269    export type TemplateLiteral = TemplateExpression | NoSubstitutionTemplateLiteral;
1270    export interface TemplateSpan extends Node {
1271        readonly kind: SyntaxKind.TemplateSpan;
1272        readonly parent: TemplateExpression;
1273        readonly expression: Expression;
1274        readonly literal: TemplateMiddle | TemplateTail;
1275    }
1276    export interface ParenthesizedExpression extends PrimaryExpression, JSDocContainer {
1277        readonly kind: SyntaxKind.ParenthesizedExpression;
1278        readonly expression: Expression;
1279    }
1280    export interface ArrayLiteralExpression extends PrimaryExpression {
1281        readonly kind: SyntaxKind.ArrayLiteralExpression;
1282        readonly elements: NodeArray<Expression>;
1283    }
1284    export interface SpreadElement extends Expression {
1285        readonly kind: SyntaxKind.SpreadElement;
1286        readonly parent: ArrayLiteralExpression | CallExpression | NewExpression;
1287        readonly expression: Expression;
1288    }
1289    /**
1290     * This interface is a base interface for ObjectLiteralExpression and JSXAttributes to extend from. JSXAttributes is similar to
1291     * ObjectLiteralExpression in that it contains array of properties; however, JSXAttributes' properties can only be
1292     * JSXAttribute or JSXSpreadAttribute. ObjectLiteralExpression, on the other hand, can only have properties of type
1293     * ObjectLiteralElement (e.g. PropertyAssignment, ShorthandPropertyAssignment etc.)
1294     */
1295    export interface ObjectLiteralExpressionBase<T extends ObjectLiteralElement> extends PrimaryExpression, Declaration {
1296        readonly properties: NodeArray<T>;
1297    }
1298    export interface ObjectLiteralExpression extends ObjectLiteralExpressionBase<ObjectLiteralElementLike> {
1299        readonly kind: SyntaxKind.ObjectLiteralExpression;
1300    }
1301    export type EntityNameExpression = Identifier | PropertyAccessEntityNameExpression;
1302    export type EntityNameOrEntityNameExpression = EntityName | EntityNameExpression;
1303    export type AccessExpression = PropertyAccessExpression | ElementAccessExpression;
1304    export interface PropertyAccessExpression extends MemberExpression, NamedDeclaration {
1305        readonly kind: SyntaxKind.PropertyAccessExpression;
1306        readonly expression: LeftHandSideExpression;
1307        readonly questionDotToken?: QuestionDotToken;
1308        readonly name: MemberName;
1309    }
1310    export interface PropertyAccessChain extends PropertyAccessExpression {
1311        _optionalChainBrand: any;
1312        readonly name: MemberName;
1313    }
1314    export interface SuperPropertyAccessExpression extends PropertyAccessExpression {
1315        readonly expression: SuperExpression;
1316    }
1317    /** Brand for a PropertyAccessExpression which, like a QualifiedName, consists of a sequence of identifiers separated by dots. */
1318    export interface PropertyAccessEntityNameExpression extends PropertyAccessExpression {
1319        _propertyAccessExpressionLikeQualifiedNameBrand?: any;
1320        readonly expression: EntityNameExpression;
1321        readonly name: Identifier;
1322    }
1323    export interface ElementAccessExpression extends MemberExpression {
1324        readonly kind: SyntaxKind.ElementAccessExpression;
1325        readonly expression: LeftHandSideExpression;
1326        readonly questionDotToken?: QuestionDotToken;
1327        readonly argumentExpression: Expression;
1328    }
1329    export interface ElementAccessChain extends ElementAccessExpression {
1330        _optionalChainBrand: any;
1331    }
1332    export interface SuperElementAccessExpression extends ElementAccessExpression {
1333        readonly expression: SuperExpression;
1334    }
1335    export type SuperProperty = SuperPropertyAccessExpression | SuperElementAccessExpression;
1336    export interface CallExpression extends LeftHandSideExpression, Declaration {
1337        readonly kind: SyntaxKind.CallExpression;
1338        readonly expression: LeftHandSideExpression;
1339        readonly questionDotToken?: QuestionDotToken;
1340        readonly typeArguments?: NodeArray<TypeNode>;
1341        readonly arguments: NodeArray<Expression>;
1342    }
1343    export interface CallChain extends CallExpression {
1344        _optionalChainBrand: any;
1345    }
1346    export type OptionalChain = PropertyAccessChain | ElementAccessChain | CallChain | NonNullChain;
1347    export interface SuperCall extends CallExpression {
1348        readonly expression: SuperExpression;
1349    }
1350    export interface ImportCall extends CallExpression {
1351        readonly expression: ImportExpression;
1352    }
1353    export interface ExpressionWithTypeArguments extends MemberExpression, NodeWithTypeArguments {
1354        readonly kind: SyntaxKind.ExpressionWithTypeArguments;
1355        readonly expression: LeftHandSideExpression;
1356    }
1357    export interface NewExpression extends PrimaryExpression, Declaration {
1358        readonly kind: SyntaxKind.NewExpression;
1359        readonly expression: LeftHandSideExpression;
1360        readonly typeArguments?: NodeArray<TypeNode>;
1361        readonly arguments?: NodeArray<Expression>;
1362    }
1363    export interface TaggedTemplateExpression extends MemberExpression {
1364        readonly kind: SyntaxKind.TaggedTemplateExpression;
1365        readonly tag: LeftHandSideExpression;
1366        readonly typeArguments?: NodeArray<TypeNode>;
1367        readonly template: TemplateLiteral;
1368    }
1369    export type CallLikeExpression = CallExpression | NewExpression | TaggedTemplateExpression | Decorator | JsxOpeningLikeElement | EtsComponentExpression;
1370    export interface AsExpression extends Expression {
1371        readonly kind: SyntaxKind.AsExpression;
1372        readonly expression: Expression;
1373        readonly type: TypeNode;
1374    }
1375    export interface TypeAssertion extends UnaryExpression {
1376        readonly kind: SyntaxKind.TypeAssertionExpression;
1377        readonly type: TypeNode;
1378        readonly expression: UnaryExpression;
1379    }
1380    export interface SatisfiesExpression extends Expression {
1381        readonly kind: SyntaxKind.SatisfiesExpression;
1382        readonly expression: Expression;
1383        readonly type: TypeNode;
1384    }
1385    export type AssertionExpression = TypeAssertion | AsExpression;
1386    export interface NonNullExpression extends LeftHandSideExpression {
1387        readonly kind: SyntaxKind.NonNullExpression;
1388        readonly expression: Expression;
1389    }
1390    export interface NonNullChain extends NonNullExpression {
1391        _optionalChainBrand: any;
1392    }
1393    export interface MetaProperty extends PrimaryExpression {
1394        readonly kind: SyntaxKind.MetaProperty;
1395        readonly keywordToken: SyntaxKind.NewKeyword | SyntaxKind.ImportKeyword;
1396        readonly name: Identifier;
1397    }
1398    export interface JsxElement extends PrimaryExpression {
1399        readonly kind: SyntaxKind.JsxElement;
1400        readonly openingElement: JsxOpeningElement;
1401        readonly children: NodeArray<JsxChild>;
1402        readonly closingElement: JsxClosingElement;
1403    }
1404    export type JsxOpeningLikeElement = JsxSelfClosingElement | JsxOpeningElement;
1405    export type JsxAttributeLike = JsxAttribute | JsxSpreadAttribute;
1406    export type JsxTagNameExpression = Identifier | ThisExpression | JsxTagNamePropertyAccess;
1407    export interface JsxTagNamePropertyAccess extends PropertyAccessExpression {
1408        readonly expression: JsxTagNameExpression;
1409    }
1410    export interface JsxAttributes extends ObjectLiteralExpressionBase<JsxAttributeLike> {
1411        readonly kind: SyntaxKind.JsxAttributes;
1412        readonly parent: JsxOpeningLikeElement;
1413    }
1414    export interface JsxOpeningElement extends Expression {
1415        readonly kind: SyntaxKind.JsxOpeningElement;
1416        readonly parent: JsxElement;
1417        readonly tagName: JsxTagNameExpression;
1418        readonly typeArguments?: NodeArray<TypeNode>;
1419        readonly attributes: JsxAttributes;
1420    }
1421    export interface JsxSelfClosingElement extends PrimaryExpression {
1422        readonly kind: SyntaxKind.JsxSelfClosingElement;
1423        readonly tagName: JsxTagNameExpression;
1424        readonly typeArguments?: NodeArray<TypeNode>;
1425        readonly attributes: JsxAttributes;
1426    }
1427    export interface JsxFragment extends PrimaryExpression {
1428        readonly kind: SyntaxKind.JsxFragment;
1429        readonly openingFragment: JsxOpeningFragment;
1430        readonly children: NodeArray<JsxChild>;
1431        readonly closingFragment: JsxClosingFragment;
1432    }
1433    export interface JsxOpeningFragment extends Expression {
1434        readonly kind: SyntaxKind.JsxOpeningFragment;
1435        readonly parent: JsxFragment;
1436    }
1437    export interface JsxClosingFragment extends Expression {
1438        readonly kind: SyntaxKind.JsxClosingFragment;
1439        readonly parent: JsxFragment;
1440    }
1441    export interface JsxAttribute extends ObjectLiteralElement {
1442        readonly kind: SyntaxKind.JsxAttribute;
1443        readonly parent: JsxAttributes;
1444        readonly name: Identifier;
1445        readonly initializer?: JsxAttributeValue;
1446    }
1447    export type JsxAttributeValue = StringLiteral | JsxExpression | JsxElement | JsxSelfClosingElement | JsxFragment;
1448    export interface JsxSpreadAttribute extends ObjectLiteralElement {
1449        readonly kind: SyntaxKind.JsxSpreadAttribute;
1450        readonly parent: JsxAttributes;
1451        readonly expression: Expression;
1452    }
1453    export interface JsxClosingElement extends Node {
1454        readonly kind: SyntaxKind.JsxClosingElement;
1455        readonly parent: JsxElement;
1456        readonly tagName: JsxTagNameExpression;
1457    }
1458    export interface JsxExpression extends Expression {
1459        readonly kind: SyntaxKind.JsxExpression;
1460        readonly parent: JsxElement | JsxFragment | JsxAttributeLike;
1461        readonly dotDotDotToken?: Token<SyntaxKind.DotDotDotToken>;
1462        readonly expression?: Expression;
1463    }
1464    export interface JsxText extends LiteralLikeNode {
1465        readonly kind: SyntaxKind.JsxText;
1466        readonly parent: JsxElement | JsxFragment;
1467        readonly containsOnlyTriviaWhiteSpaces: boolean;
1468    }
1469    export type JsxChild = JsxText | JsxExpression | JsxElement | JsxSelfClosingElement | JsxFragment;
1470    export interface Statement extends Node, JSDocContainer {
1471        _statementBrand: any;
1472    }
1473    export interface NotEmittedStatement extends Statement {
1474        readonly kind: SyntaxKind.NotEmittedStatement;
1475    }
1476    /**
1477     * A list of comma-separated expressions. This node is only created by transformations.
1478     */
1479    export interface CommaListExpression extends Expression {
1480        readonly kind: SyntaxKind.CommaListExpression;
1481        readonly elements: NodeArray<Expression>;
1482    }
1483    export interface EmptyStatement extends Statement {
1484        readonly kind: SyntaxKind.EmptyStatement;
1485    }
1486    export interface DebuggerStatement extends Statement {
1487        readonly kind: SyntaxKind.DebuggerStatement;
1488    }
1489    export interface MissingDeclaration extends DeclarationStatement {
1490        readonly kind: SyntaxKind.MissingDeclaration;
1491        readonly name?: Identifier;
1492    }
1493    export type BlockLike = SourceFile | Block | ModuleBlock | CaseOrDefaultClause;
1494    export interface Block extends Statement {
1495        readonly kind: SyntaxKind.Block;
1496        readonly statements: NodeArray<Statement>;
1497    }
1498    export interface VariableStatement extends Statement {
1499        readonly kind: SyntaxKind.VariableStatement;
1500        readonly modifiers?: NodeArray<Modifier>;
1501        readonly declarationList: VariableDeclarationList;
1502    }
1503    export interface ExpressionStatement extends Statement {
1504        readonly kind: SyntaxKind.ExpressionStatement;
1505        readonly expression: Expression;
1506    }
1507    export interface IfStatement extends Statement {
1508        readonly kind: SyntaxKind.IfStatement;
1509        readonly expression: Expression;
1510        readonly thenStatement: Statement;
1511        readonly elseStatement?: Statement;
1512    }
1513    export interface IterationStatement extends Statement {
1514        readonly statement: Statement;
1515    }
1516    export interface DoStatement extends IterationStatement {
1517        readonly kind: SyntaxKind.DoStatement;
1518        readonly expression: Expression;
1519    }
1520    export interface WhileStatement extends IterationStatement {
1521        readonly kind: SyntaxKind.WhileStatement;
1522        readonly expression: Expression;
1523    }
1524    export type ForInitializer = VariableDeclarationList | Expression;
1525    export interface ForStatement extends IterationStatement {
1526        readonly kind: SyntaxKind.ForStatement;
1527        readonly initializer?: ForInitializer;
1528        readonly condition?: Expression;
1529        readonly incrementor?: Expression;
1530    }
1531    export type ForInOrOfStatement = ForInStatement | ForOfStatement;
1532    export interface ForInStatement extends IterationStatement {
1533        readonly kind: SyntaxKind.ForInStatement;
1534        readonly initializer: ForInitializer;
1535        readonly expression: Expression;
1536    }
1537    export interface ForOfStatement extends IterationStatement {
1538        readonly kind: SyntaxKind.ForOfStatement;
1539        readonly awaitModifier?: AwaitKeyword;
1540        readonly initializer: ForInitializer;
1541        readonly expression: Expression;
1542    }
1543    export interface BreakStatement extends Statement {
1544        readonly kind: SyntaxKind.BreakStatement;
1545        readonly label?: Identifier;
1546    }
1547    export interface ContinueStatement extends Statement {
1548        readonly kind: SyntaxKind.ContinueStatement;
1549        readonly label?: Identifier;
1550    }
1551    export type BreakOrContinueStatement = BreakStatement | ContinueStatement;
1552    export interface ReturnStatement extends Statement {
1553        readonly kind: SyntaxKind.ReturnStatement;
1554        readonly expression?: Expression;
1555    }
1556    export interface WithStatement extends Statement {
1557        readonly kind: SyntaxKind.WithStatement;
1558        readonly expression: Expression;
1559        readonly statement: Statement;
1560    }
1561    export interface SwitchStatement extends Statement {
1562        readonly kind: SyntaxKind.SwitchStatement;
1563        readonly expression: Expression;
1564        readonly caseBlock: CaseBlock;
1565        possiblyExhaustive?: boolean;
1566    }
1567    export interface CaseBlock extends Node {
1568        readonly kind: SyntaxKind.CaseBlock;
1569        readonly parent: SwitchStatement;
1570        readonly clauses: NodeArray<CaseOrDefaultClause>;
1571    }
1572    export interface CaseClause extends Node, JSDocContainer {
1573        readonly kind: SyntaxKind.CaseClause;
1574        readonly parent: CaseBlock;
1575        readonly expression: Expression;
1576        readonly statements: NodeArray<Statement>;
1577    }
1578    export interface DefaultClause extends Node {
1579        readonly kind: SyntaxKind.DefaultClause;
1580        readonly parent: CaseBlock;
1581        readonly statements: NodeArray<Statement>;
1582    }
1583    export type CaseOrDefaultClause = CaseClause | DefaultClause;
1584    export interface LabeledStatement extends Statement {
1585        readonly kind: SyntaxKind.LabeledStatement;
1586        readonly label: Identifier;
1587        readonly statement: Statement;
1588    }
1589    export interface ThrowStatement extends Statement {
1590        readonly kind: SyntaxKind.ThrowStatement;
1591        readonly expression: Expression;
1592    }
1593    export interface TryStatement extends Statement {
1594        readonly kind: SyntaxKind.TryStatement;
1595        readonly tryBlock: Block;
1596        readonly catchClause?: CatchClause;
1597        readonly finallyBlock?: Block;
1598    }
1599    export interface CatchClause extends Node {
1600        readonly kind: SyntaxKind.CatchClause;
1601        readonly parent: TryStatement;
1602        readonly variableDeclaration?: VariableDeclaration;
1603        readonly block: Block;
1604    }
1605    export type ObjectTypeDeclaration = ClassLikeDeclaration | InterfaceDeclaration | TypeLiteralNode;
1606    export type DeclarationWithTypeParameters = DeclarationWithTypeParameterChildren | JSDocTypedefTag | JSDocCallbackTag | JSDocSignature;
1607    export type DeclarationWithTypeParameterChildren = SignatureDeclaration | ClassLikeDeclaration | InterfaceDeclaration | TypeAliasDeclaration | JSDocTemplateTag;
1608    export interface ClassLikeDeclarationBase extends NamedDeclaration, JSDocContainer {
1609        readonly kind: SyntaxKind.ClassDeclaration | SyntaxKind.ClassExpression | SyntaxKind.StructDeclaration;
1610        readonly name?: Identifier;
1611        readonly typeParameters?: NodeArray<TypeParameterDeclaration>;
1612        readonly heritageClauses?: NodeArray<HeritageClause>;
1613        readonly members: NodeArray<ClassElement>;
1614    }
1615    export interface ClassDeclaration extends ClassLikeDeclarationBase, DeclarationStatement {
1616        readonly kind: SyntaxKind.ClassDeclaration;
1617        readonly modifiers?: NodeArray<ModifierLike>;
1618        /** May be undefined in `export default class { ... }`. */
1619        readonly name?: Identifier;
1620    }
1621    export interface StructDeclaration extends ClassLikeDeclarationBase, DeclarationStatement {
1622        readonly kind: SyntaxKind.StructDeclaration;
1623        readonly modifiers?: NodeArray<ModifierLike>;
1624        /** May be undefined in `export default class { ... }`. */
1625        readonly name?: Identifier;
1626    }
1627    export interface ClassExpression extends ClassLikeDeclarationBase, PrimaryExpression {
1628        readonly kind: SyntaxKind.ClassExpression;
1629        readonly modifiers?: NodeArray<ModifierLike>;
1630    }
1631    export type ClassLikeDeclaration = ClassDeclaration | ClassExpression | StructDeclaration;
1632    export interface ClassElement extends NamedDeclaration {
1633        _classElementBrand: any;
1634        readonly name?: PropertyName;
1635    }
1636    export interface TypeElement extends NamedDeclaration {
1637        _typeElementBrand: any;
1638        readonly name?: PropertyName;
1639        readonly questionToken?: QuestionToken | undefined;
1640    }
1641    export interface InterfaceDeclaration extends DeclarationStatement, JSDocContainer {
1642        readonly kind: SyntaxKind.InterfaceDeclaration;
1643        readonly modifiers?: NodeArray<Modifier>;
1644        readonly name: Identifier;
1645        readonly typeParameters?: NodeArray<TypeParameterDeclaration>;
1646        readonly heritageClauses?: NodeArray<HeritageClause>;
1647        readonly members: NodeArray<TypeElement>;
1648    }
1649    export interface HeritageClause extends Node {
1650        readonly kind: SyntaxKind.HeritageClause;
1651        readonly parent: InterfaceDeclaration | ClassLikeDeclaration;
1652        readonly token: SyntaxKind.ExtendsKeyword | SyntaxKind.ImplementsKeyword;
1653        readonly types: NodeArray<ExpressionWithTypeArguments>;
1654    }
1655    export interface TypeAliasDeclaration extends DeclarationStatement, JSDocContainer {
1656        readonly kind: SyntaxKind.TypeAliasDeclaration;
1657        readonly modifiers?: NodeArray<Modifier>;
1658        readonly name: Identifier;
1659        readonly typeParameters?: NodeArray<TypeParameterDeclaration>;
1660        readonly type: TypeNode;
1661    }
1662    export interface EnumMember extends NamedDeclaration, JSDocContainer {
1663        readonly kind: SyntaxKind.EnumMember;
1664        readonly parent: EnumDeclaration;
1665        readonly name: PropertyName;
1666        readonly initializer?: Expression;
1667    }
1668    export interface EnumDeclaration extends DeclarationStatement, JSDocContainer {
1669        readonly kind: SyntaxKind.EnumDeclaration;
1670        readonly modifiers?: NodeArray<Modifier>;
1671        readonly name: Identifier;
1672        readonly members: NodeArray<EnumMember>;
1673    }
1674    export type ModuleName = Identifier | StringLiteral;
1675    export type ModuleBody = NamespaceBody | JSDocNamespaceBody;
1676    export interface ModuleDeclaration extends DeclarationStatement, JSDocContainer {
1677        readonly kind: SyntaxKind.ModuleDeclaration;
1678        readonly parent: ModuleBody | SourceFile;
1679        readonly modifiers?: NodeArray<Modifier>;
1680        readonly name: ModuleName;
1681        readonly body?: ModuleBody | JSDocNamespaceDeclaration;
1682    }
1683    export type NamespaceBody = ModuleBlock | NamespaceDeclaration;
1684    export interface NamespaceDeclaration extends ModuleDeclaration {
1685        readonly name: Identifier;
1686        readonly body: NamespaceBody;
1687    }
1688    export type JSDocNamespaceBody = Identifier | JSDocNamespaceDeclaration;
1689    export interface JSDocNamespaceDeclaration extends ModuleDeclaration {
1690        readonly name: Identifier;
1691        readonly body?: JSDocNamespaceBody;
1692    }
1693    export interface ModuleBlock extends Node, Statement {
1694        readonly kind: SyntaxKind.ModuleBlock;
1695        readonly parent: ModuleDeclaration;
1696        readonly statements: NodeArray<Statement>;
1697    }
1698    export type ModuleReference = EntityName | ExternalModuleReference;
1699    /**
1700     * One of:
1701     * - import x = require("mod");
1702     * - import x = M.x;
1703     */
1704    export interface ImportEqualsDeclaration extends DeclarationStatement, JSDocContainer {
1705        readonly kind: SyntaxKind.ImportEqualsDeclaration;
1706        readonly parent: SourceFile | ModuleBlock;
1707        readonly modifiers?: NodeArray<Modifier>;
1708        readonly name: Identifier;
1709        readonly isTypeOnly: boolean;
1710        readonly moduleReference: ModuleReference;
1711    }
1712    export interface ExternalModuleReference extends Node {
1713        readonly kind: SyntaxKind.ExternalModuleReference;
1714        readonly parent: ImportEqualsDeclaration;
1715        readonly expression: Expression;
1716    }
1717    export interface ImportDeclaration extends Statement {
1718        readonly kind: SyntaxKind.ImportDeclaration;
1719        readonly parent: SourceFile | ModuleBlock;
1720        readonly modifiers?: NodeArray<Modifier>;
1721        readonly importClause?: ImportClause;
1722        /** If this is not a StringLiteral it will be a grammar error. */
1723        readonly moduleSpecifier: Expression;
1724        readonly assertClause?: AssertClause;
1725    }
1726    export type NamedImportBindings = NamespaceImport | NamedImports;
1727    export type NamedExportBindings = NamespaceExport | NamedExports;
1728    export interface ImportClause extends NamedDeclaration {
1729        readonly kind: SyntaxKind.ImportClause;
1730        readonly parent: ImportDeclaration;
1731        readonly isTypeOnly: boolean;
1732        readonly name?: Identifier;
1733        readonly namedBindings?: NamedImportBindings;
1734        readonly isLazy?: boolean;
1735    }
1736    export type AssertionKey = Identifier | StringLiteral;
1737    export interface AssertEntry extends Node {
1738        readonly kind: SyntaxKind.AssertEntry;
1739        readonly parent: AssertClause;
1740        readonly name: AssertionKey;
1741        readonly value: Expression;
1742    }
1743    export interface AssertClause extends Node {
1744        readonly kind: SyntaxKind.AssertClause;
1745        readonly parent: ImportDeclaration | ExportDeclaration;
1746        readonly elements: NodeArray<AssertEntry>;
1747        readonly multiLine?: boolean;
1748    }
1749    export interface NamespaceImport extends NamedDeclaration {
1750        readonly kind: SyntaxKind.NamespaceImport;
1751        readonly parent: ImportClause;
1752        readonly name: Identifier;
1753    }
1754    export interface NamespaceExport extends NamedDeclaration {
1755        readonly kind: SyntaxKind.NamespaceExport;
1756        readonly parent: ExportDeclaration;
1757        readonly name: Identifier;
1758    }
1759    export interface NamespaceExportDeclaration extends DeclarationStatement, JSDocContainer {
1760        readonly kind: SyntaxKind.NamespaceExportDeclaration;
1761        readonly name: Identifier;
1762    }
1763    export interface ExportDeclaration extends DeclarationStatement, JSDocContainer {
1764        readonly kind: SyntaxKind.ExportDeclaration;
1765        readonly parent: SourceFile | ModuleBlock;
1766        readonly modifiers?: NodeArray<Modifier>;
1767        readonly isTypeOnly: boolean;
1768        /** Will not be assigned in the case of `export * from "foo";` */
1769        readonly exportClause?: NamedExportBindings;
1770        /** If this is not a StringLiteral it will be a grammar error. */
1771        readonly moduleSpecifier?: Expression;
1772        readonly assertClause?: AssertClause;
1773    }
1774    export interface NamedImports extends Node {
1775        readonly kind: SyntaxKind.NamedImports;
1776        readonly parent: ImportClause;
1777        readonly elements: NodeArray<ImportSpecifier>;
1778    }
1779    export interface NamedExports extends Node {
1780        readonly kind: SyntaxKind.NamedExports;
1781        readonly parent: ExportDeclaration;
1782        readonly elements: NodeArray<ExportSpecifier>;
1783    }
1784    export type NamedImportsOrExports = NamedImports | NamedExports;
1785    export interface ImportSpecifier extends NamedDeclaration {
1786        readonly kind: SyntaxKind.ImportSpecifier;
1787        readonly parent: NamedImports;
1788        readonly propertyName?: Identifier;
1789        readonly name: Identifier;
1790        readonly isTypeOnly: boolean;
1791    }
1792    export interface ExportSpecifier extends NamedDeclaration, JSDocContainer {
1793        readonly kind: SyntaxKind.ExportSpecifier;
1794        readonly parent: NamedExports;
1795        readonly isTypeOnly: boolean;
1796        readonly propertyName?: Identifier;
1797        readonly name: Identifier;
1798    }
1799    export type ImportOrExportSpecifier = ImportSpecifier | ExportSpecifier;
1800    export type TypeOnlyCompatibleAliasDeclaration = ImportClause | ImportEqualsDeclaration | NamespaceImport | ImportOrExportSpecifier;
1801    export type TypeOnlyAliasDeclaration = ImportClause & {
1802        readonly isTypeOnly: true;
1803        readonly name: Identifier;
1804    } | ImportEqualsDeclaration & {
1805        readonly isTypeOnly: true;
1806    } | NamespaceImport & {
1807        readonly parent: ImportClause & {
1808            readonly isTypeOnly: true;
1809        };
1810    } | ImportSpecifier & ({
1811        readonly isTypeOnly: true;
1812    } | {
1813        readonly parent: NamedImports & {
1814            readonly parent: ImportClause & {
1815                readonly isTypeOnly: true;
1816            };
1817        };
1818    }) | ExportSpecifier & ({
1819        readonly isTypeOnly: true;
1820    } | {
1821        readonly parent: NamedExports & {
1822            readonly parent: ExportDeclaration & {
1823                readonly isTypeOnly: true;
1824            };
1825        };
1826    });
1827    /**
1828     * This is either an `export =` or an `export default` declaration.
1829     * Unless `isExportEquals` is set, this node was parsed as an `export default`.
1830     */
1831    export interface ExportAssignment extends DeclarationStatement, JSDocContainer {
1832        readonly kind: SyntaxKind.ExportAssignment;
1833        readonly parent: SourceFile;
1834        readonly modifiers?: NodeArray<Modifier>;
1835        readonly isExportEquals?: boolean;
1836        readonly expression: Expression;
1837    }
1838    export interface FileReference extends TextRange {
1839        fileName: string;
1840        resolutionMode?: SourceFile["impliedNodeFormat"];
1841    }
1842    export interface CheckJsDirective extends TextRange {
1843        enabled: boolean;
1844    }
1845    export type CommentKind = SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia;
1846    export interface CommentRange extends TextRange {
1847        hasTrailingNewLine?: boolean;
1848        kind: CommentKind;
1849    }
1850    export interface SynthesizedComment extends CommentRange {
1851        text: string;
1852        pos: -1;
1853        end: -1;
1854        hasLeadingNewline?: boolean;
1855    }
1856    export interface JSDocTypeExpression extends TypeNode {
1857        readonly kind: SyntaxKind.JSDocTypeExpression;
1858        readonly type: TypeNode;
1859    }
1860    export interface JSDocNameReference extends Node {
1861        readonly kind: SyntaxKind.JSDocNameReference;
1862        readonly name: EntityName | JSDocMemberName;
1863    }
1864    /** Class#method reference in JSDoc */
1865    export interface JSDocMemberName extends Node {
1866        readonly kind: SyntaxKind.JSDocMemberName;
1867        readonly left: EntityName | JSDocMemberName;
1868        readonly right: Identifier;
1869    }
1870    export interface JSDocType extends TypeNode {
1871        _jsDocTypeBrand: any;
1872    }
1873    export interface JSDocAllType extends JSDocType {
1874        readonly kind: SyntaxKind.JSDocAllType;
1875    }
1876    export interface JSDocUnknownType extends JSDocType {
1877        readonly kind: SyntaxKind.JSDocUnknownType;
1878    }
1879    export interface JSDocNonNullableType extends JSDocType {
1880        readonly kind: SyntaxKind.JSDocNonNullableType;
1881        readonly type: TypeNode;
1882        readonly postfix: boolean;
1883    }
1884    export interface JSDocNullableType extends JSDocType {
1885        readonly kind: SyntaxKind.JSDocNullableType;
1886        readonly type: TypeNode;
1887        readonly postfix: boolean;
1888    }
1889    export interface JSDocOptionalType extends JSDocType {
1890        readonly kind: SyntaxKind.JSDocOptionalType;
1891        readonly type: TypeNode;
1892    }
1893    export interface JSDocFunctionType extends JSDocType, SignatureDeclarationBase {
1894        readonly kind: SyntaxKind.JSDocFunctionType;
1895    }
1896    export interface JSDocVariadicType extends JSDocType {
1897        readonly kind: SyntaxKind.JSDocVariadicType;
1898        readonly type: TypeNode;
1899    }
1900    export interface JSDocNamepathType extends JSDocType {
1901        readonly kind: SyntaxKind.JSDocNamepathType;
1902        readonly type: TypeNode;
1903    }
1904    export type JSDocTypeReferencingNode = JSDocVariadicType | JSDocOptionalType | JSDocNullableType | JSDocNonNullableType;
1905    export interface JSDoc extends Node {
1906        readonly kind: SyntaxKind.JSDoc;
1907        readonly parent: HasJSDoc;
1908        readonly tags?: NodeArray<JSDocTag>;
1909        readonly comment?: string | NodeArray<JSDocComment>;
1910    }
1911    export interface JSDocTag extends Node {
1912        readonly parent: JSDoc | JSDocTypeLiteral;
1913        readonly tagName: Identifier;
1914        readonly comment?: string | NodeArray<JSDocComment>;
1915    }
1916    export interface JSDocLink extends Node {
1917        readonly kind: SyntaxKind.JSDocLink;
1918        readonly name?: EntityName | JSDocMemberName;
1919        text: string;
1920    }
1921    export interface JSDocLinkCode extends Node {
1922        readonly kind: SyntaxKind.JSDocLinkCode;
1923        readonly name?: EntityName | JSDocMemberName;
1924        text: string;
1925    }
1926    export interface JSDocLinkPlain extends Node {
1927        readonly kind: SyntaxKind.JSDocLinkPlain;
1928        readonly name?: EntityName | JSDocMemberName;
1929        text: string;
1930    }
1931    export type JSDocComment = JSDocText | JSDocLink | JSDocLinkCode | JSDocLinkPlain;
1932    export interface JSDocText extends Node {
1933        readonly kind: SyntaxKind.JSDocText;
1934        text: string;
1935    }
1936    export interface JSDocUnknownTag extends JSDocTag {
1937        readonly kind: SyntaxKind.JSDocTag;
1938    }
1939    /**
1940     * Note that `@extends` is a synonym of `@augments`.
1941     * Both tags are represented by this interface.
1942     */
1943    export interface JSDocAugmentsTag extends JSDocTag {
1944        readonly kind: SyntaxKind.JSDocAugmentsTag;
1945        readonly class: ExpressionWithTypeArguments & {
1946            readonly expression: Identifier | PropertyAccessEntityNameExpression;
1947        };
1948    }
1949    export interface JSDocImplementsTag extends JSDocTag {
1950        readonly kind: SyntaxKind.JSDocImplementsTag;
1951        readonly class: ExpressionWithTypeArguments & {
1952            readonly expression: Identifier | PropertyAccessEntityNameExpression;
1953        };
1954    }
1955    export interface JSDocAuthorTag extends JSDocTag {
1956        readonly kind: SyntaxKind.JSDocAuthorTag;
1957    }
1958    export interface JSDocDeprecatedTag extends JSDocTag {
1959        kind: SyntaxKind.JSDocDeprecatedTag;
1960    }
1961    export interface JSDocClassTag extends JSDocTag {
1962        readonly kind: SyntaxKind.JSDocClassTag;
1963    }
1964    export interface JSDocPublicTag extends JSDocTag {
1965        readonly kind: SyntaxKind.JSDocPublicTag;
1966    }
1967    export interface JSDocPrivateTag extends JSDocTag {
1968        readonly kind: SyntaxKind.JSDocPrivateTag;
1969    }
1970    export interface JSDocProtectedTag extends JSDocTag {
1971        readonly kind: SyntaxKind.JSDocProtectedTag;
1972    }
1973    export interface JSDocReadonlyTag extends JSDocTag {
1974        readonly kind: SyntaxKind.JSDocReadonlyTag;
1975    }
1976    export interface JSDocOverrideTag extends JSDocTag {
1977        readonly kind: SyntaxKind.JSDocOverrideTag;
1978    }
1979    export interface JSDocEnumTag extends JSDocTag, Declaration {
1980        readonly kind: SyntaxKind.JSDocEnumTag;
1981        readonly parent: JSDoc;
1982        readonly typeExpression: JSDocTypeExpression;
1983    }
1984    export interface JSDocThisTag extends JSDocTag {
1985        readonly kind: SyntaxKind.JSDocThisTag;
1986        readonly typeExpression: JSDocTypeExpression;
1987    }
1988    export interface JSDocTemplateTag extends JSDocTag {
1989        readonly kind: SyntaxKind.JSDocTemplateTag;
1990        readonly constraint: JSDocTypeExpression | undefined;
1991        readonly typeParameters: NodeArray<TypeParameterDeclaration>;
1992    }
1993    export interface JSDocSeeTag extends JSDocTag {
1994        readonly kind: SyntaxKind.JSDocSeeTag;
1995        readonly name?: JSDocNameReference;
1996    }
1997    export interface JSDocReturnTag extends JSDocTag {
1998        readonly kind: SyntaxKind.JSDocReturnTag;
1999        readonly typeExpression?: JSDocTypeExpression;
2000    }
2001    export interface JSDocTypeTag extends JSDocTag {
2002        readonly kind: SyntaxKind.JSDocTypeTag;
2003        readonly typeExpression: JSDocTypeExpression;
2004    }
2005    export interface JSDocTypedefTag extends JSDocTag, NamedDeclaration {
2006        readonly kind: SyntaxKind.JSDocTypedefTag;
2007        readonly parent: JSDoc;
2008        readonly fullName?: JSDocNamespaceDeclaration | Identifier;
2009        readonly name?: Identifier;
2010        readonly typeExpression?: JSDocTypeExpression | JSDocTypeLiteral;
2011    }
2012    export interface JSDocCallbackTag extends JSDocTag, NamedDeclaration {
2013        readonly kind: SyntaxKind.JSDocCallbackTag;
2014        readonly parent: JSDoc;
2015        readonly fullName?: JSDocNamespaceDeclaration | Identifier;
2016        readonly name?: Identifier;
2017        readonly typeExpression: JSDocSignature;
2018    }
2019    export interface JSDocSignature extends JSDocType, Declaration {
2020        readonly kind: SyntaxKind.JSDocSignature;
2021        readonly typeParameters?: readonly JSDocTemplateTag[];
2022        readonly parameters: readonly JSDocParameterTag[];
2023        readonly type: JSDocReturnTag | undefined;
2024    }
2025    export interface JSDocPropertyLikeTag extends JSDocTag, Declaration {
2026        readonly parent: JSDoc;
2027        readonly name: EntityName;
2028        readonly typeExpression?: JSDocTypeExpression;
2029        /** Whether the property name came before the type -- non-standard for JSDoc, but Typescript-like */
2030        readonly isNameFirst: boolean;
2031        readonly isBracketed: boolean;
2032    }
2033    export interface JSDocPropertyTag extends JSDocPropertyLikeTag {
2034        readonly kind: SyntaxKind.JSDocPropertyTag;
2035    }
2036    export interface JSDocParameterTag extends JSDocPropertyLikeTag {
2037        readonly kind: SyntaxKind.JSDocParameterTag;
2038    }
2039    export interface JSDocTypeLiteral extends JSDocType {
2040        readonly kind: SyntaxKind.JSDocTypeLiteral;
2041        readonly jsDocPropertyTags?: readonly JSDocPropertyLikeTag[];
2042        /** If true, then this type literal represents an *array* of its type. */
2043        readonly isArrayType: boolean;
2044    }
2045    export enum FlowFlags {
2046        Unreachable = 1,
2047        Start = 2,
2048        BranchLabel = 4,
2049        LoopLabel = 8,
2050        Assignment = 16,
2051        TrueCondition = 32,
2052        FalseCondition = 64,
2053        SwitchClause = 128,
2054        ArrayMutation = 256,
2055        Call = 512,
2056        ReduceLabel = 1024,
2057        Referenced = 2048,
2058        Shared = 4096,
2059        Label = 12,
2060        Condition = 96
2061    }
2062    export type FlowNode = FlowStart | FlowLabel | FlowAssignment | FlowCondition | FlowSwitchClause | FlowArrayMutation | FlowCall | FlowReduceLabel;
2063    export interface FlowNodeBase {
2064        flags: FlowFlags;
2065        id?: number;
2066    }
2067    export interface FlowStart extends FlowNodeBase {
2068        node?: FunctionExpression | ArrowFunction | MethodDeclaration | GetAccessorDeclaration | SetAccessorDeclaration;
2069    }
2070    export interface FlowLabel extends FlowNodeBase {
2071        antecedents: FlowNode[] | undefined;
2072    }
2073    export interface FlowAssignment extends FlowNodeBase {
2074        node: Expression | VariableDeclaration | BindingElement;
2075        antecedent: FlowNode;
2076    }
2077    export interface FlowCall extends FlowNodeBase {
2078        node: CallExpression;
2079        antecedent: FlowNode;
2080    }
2081    export interface FlowCondition extends FlowNodeBase {
2082        node: Expression;
2083        antecedent: FlowNode;
2084    }
2085    export interface FlowSwitchClause extends FlowNodeBase {
2086        switchStatement: SwitchStatement;
2087        clauseStart: number;
2088        clauseEnd: number;
2089        antecedent: FlowNode;
2090    }
2091    export interface FlowArrayMutation extends FlowNodeBase {
2092        node: CallExpression | BinaryExpression;
2093        antecedent: FlowNode;
2094    }
2095    export interface FlowReduceLabel extends FlowNodeBase {
2096        target: FlowLabel;
2097        antecedents: FlowNode[];
2098        antecedent: FlowNode;
2099    }
2100    export type FlowType = Type | IncompleteType;
2101    export interface IncompleteType {
2102        flags: TypeFlags;
2103        type: Type;
2104    }
2105    export interface AmdDependency {
2106        path: string;
2107        name?: string;
2108    }
2109    /**
2110     * Subset of properties from SourceFile that are used in multiple utility functions
2111     */
2112    export interface SourceFileLike {
2113        readonly text: string;
2114        readonly fileName?: string;
2115    }
2116    export interface SourceFile extends Declaration {
2117        readonly kind: SyntaxKind.SourceFile;
2118        readonly statements: NodeArray<Statement>;
2119        readonly endOfFileToken: Token<SyntaxKind.EndOfFileToken>;
2120        fileName: string;
2121        text: string;
2122        amdDependencies: readonly AmdDependency[];
2123        moduleName?: string;
2124        referencedFiles: readonly FileReference[];
2125        typeReferenceDirectives: readonly FileReference[];
2126        libReferenceDirectives: readonly FileReference[];
2127        languageVariant: LanguageVariant;
2128        isDeclarationFile: boolean;
2129        /**
2130         * lib.d.ts should have a reference comment like
2131         *
2132         *  /// <reference no-default-lib="true"/>
2133         *
2134         * If any other file has this comment, it signals not to include lib.d.ts
2135         * because this containing file is intended to act as a default library.
2136         */
2137        hasNoDefaultLib: boolean;
2138        languageVersion: ScriptTarget;
2139        /**
2140         * When `module` is `Node16` or `NodeNext`, this field controls whether the
2141         * source file in question is an ESNext-output-format file, or a CommonJS-output-format
2142         * module. This is derived by the module resolver as it looks up the file, since
2143         * it is derived from either the file extension of the module, or the containing
2144         * `package.json` context, and affects both checking and emit.
2145         *
2146         * It is _public_ so that (pre)transformers can set this field,
2147         * since it switches the builtin `node` module transform. Generally speaking, if unset,
2148         * the field is treated as though it is `ModuleKind.CommonJS`.
2149         *
2150         * Note that this field is only set by the module resolution process when
2151         * `moduleResolution` is `Node16` or `NodeNext`, which is implied by the `module` setting
2152         * of `Node16` or `NodeNext`, respectively, but may be overriden (eg, by a `moduleResolution`
2153         * of `node`). If so, this field will be unset and source files will be considered to be
2154         * CommonJS-output-format by the node module transformer and type checker, regardless of extension or context.
2155         */
2156        impliedNodeFormat?: ModuleKind.ESNext | ModuleKind.CommonJS;
2157    }
2158    export interface Bundle extends Node {
2159        readonly kind: SyntaxKind.Bundle;
2160        readonly prepends: readonly (InputFiles | UnparsedSource)[];
2161        readonly sourceFiles: readonly SourceFile[];
2162    }
2163    export interface InputFiles extends Node {
2164        readonly kind: SyntaxKind.InputFiles;
2165        javascriptPath?: string;
2166        javascriptText: string;
2167        javascriptMapPath?: string;
2168        javascriptMapText?: string;
2169        declarationPath?: string;
2170        declarationText: string;
2171        declarationMapPath?: string;
2172        declarationMapText?: string;
2173    }
2174    export interface UnparsedSource extends Node {
2175        readonly kind: SyntaxKind.UnparsedSource;
2176        fileName: string;
2177        text: string;
2178        readonly prologues: readonly UnparsedPrologue[];
2179        helpers: readonly UnscopedEmitHelper[] | undefined;
2180        referencedFiles: readonly FileReference[];
2181        typeReferenceDirectives: readonly FileReference[] | undefined;
2182        libReferenceDirectives: readonly FileReference[];
2183        hasNoDefaultLib?: boolean;
2184        sourceMapPath?: string;
2185        sourceMapText?: string;
2186        readonly syntheticReferences?: readonly UnparsedSyntheticReference[];
2187        readonly texts: readonly UnparsedSourceText[];
2188    }
2189    export type UnparsedSourceText = UnparsedPrepend | UnparsedTextLike;
2190    export type UnparsedNode = UnparsedPrologue | UnparsedSourceText | UnparsedSyntheticReference;
2191    export interface UnparsedSection extends Node {
2192        readonly kind: SyntaxKind;
2193        readonly parent: UnparsedSource;
2194        readonly data?: string;
2195    }
2196    export interface UnparsedPrologue extends UnparsedSection {
2197        readonly kind: SyntaxKind.UnparsedPrologue;
2198        readonly parent: UnparsedSource;
2199        readonly data: string;
2200    }
2201    export interface UnparsedPrepend extends UnparsedSection {
2202        readonly kind: SyntaxKind.UnparsedPrepend;
2203        readonly parent: UnparsedSource;
2204        readonly data: string;
2205        readonly texts: readonly UnparsedTextLike[];
2206    }
2207    export interface UnparsedTextLike extends UnparsedSection {
2208        readonly kind: SyntaxKind.UnparsedText | SyntaxKind.UnparsedInternalText;
2209        readonly parent: UnparsedSource;
2210    }
2211    export interface UnparsedSyntheticReference extends UnparsedSection {
2212        readonly kind: SyntaxKind.UnparsedSyntheticReference;
2213        readonly parent: UnparsedSource;
2214    }
2215    export interface JsonSourceFile extends SourceFile {
2216        readonly statements: NodeArray<JsonObjectExpressionStatement>;
2217    }
2218    export interface TsConfigSourceFile extends JsonSourceFile {
2219        extendedSourceFiles?: string[];
2220    }
2221    export interface JsonMinusNumericLiteral extends PrefixUnaryExpression {
2222        readonly kind: SyntaxKind.PrefixUnaryExpression;
2223        readonly operator: SyntaxKind.MinusToken;
2224        readonly operand: NumericLiteral;
2225    }
2226    export type JsonObjectExpression = ObjectLiteralExpression | ArrayLiteralExpression | JsonMinusNumericLiteral | NumericLiteral | StringLiteral | BooleanLiteral | NullLiteral;
2227    export interface JsonObjectExpressionStatement extends ExpressionStatement {
2228        readonly expression: JsonObjectExpression;
2229    }
2230    export interface ScriptReferenceHost {
2231        getCompilerOptions(): CompilerOptions;
2232        getSourceFile(fileName: string): SourceFile | undefined;
2233        getSourceFileByPath(path: Path): SourceFile | undefined;
2234        getCurrentDirectory(): string;
2235    }
2236    export interface ParseConfigHost {
2237        useCaseSensitiveFileNames: boolean;
2238        readDirectory(rootDir: string, extensions: readonly string[], excludes: readonly string[] | undefined, includes: readonly string[], depth?: number): readonly string[];
2239        /**
2240         * Gets a value indicating whether the specified path exists and is a file.
2241         * @param path The path to test.
2242         */
2243        fileExists(path: string): boolean;
2244        readFile(path: string): string | undefined;
2245        trace?(s: string): void;
2246    }
2247    /**
2248     * Branded string for keeping track of when we've turned an ambiguous path
2249     * specified like "./blah" to an absolute path to an actual
2250     * tsconfig file, e.g. "/root/blah/tsconfig.json"
2251     */
2252    export type ResolvedConfigFileName = string & {
2253        _isResolvedConfigFileName: never;
2254    };
2255    export interface WriteFileCallbackData {
2256    }
2257    export type WriteFileCallback = (fileName: string, text: string, writeByteOrderMark: boolean, onError?: (message: string) => void, sourceFiles?: readonly SourceFile[], data?: WriteFileCallbackData) => void;
2258    export class OperationCanceledException {
2259    }
2260    export interface CancellationToken {
2261        isCancellationRequested(): boolean;
2262        /** @throws OperationCanceledException if isCancellationRequested is true */
2263        throwIfCancellationRequested(): void;
2264    }
2265    export interface SymbolDisplayPart {
2266        text: string;
2267        kind: string;
2268    }
2269    export interface JsDocTagInfo {
2270        name: string;
2271        text?: string | SymbolDisplayPart[];
2272    }
2273    export interface Program extends ScriptReferenceHost {
2274        getCurrentDirectory(): string;
2275        /**
2276         * Get a list of root file names that were passed to a 'createProgram'
2277         */
2278        getRootFileNames(): readonly string[];
2279        /**
2280         * Get a list of files in the program
2281         */
2282        getSourceFiles(): readonly SourceFile[];
2283        /**
2284         * Emits the JavaScript and declaration files.  If targetSourceFile is not specified, then
2285         * the JavaScript and declaration files will be produced for all the files in this program.
2286         * If targetSourceFile is specified, then only the JavaScript and declaration for that
2287         * specific file will be generated.
2288         *
2289         * If writeFile is not specified then the writeFile callback from the compiler host will be
2290         * used for writing the JavaScript and declaration files.  Otherwise, the writeFile parameter
2291         * will be invoked when writing the JavaScript and declaration files.
2292         */
2293        emit(targetSourceFile?: SourceFile, writeFile?: WriteFileCallback, cancellationToken?: CancellationToken, emitOnlyDtsFiles?: boolean, customTransformers?: CustomTransformers): EmitResult;
2294        getOptionsDiagnostics(cancellationToken?: CancellationToken): readonly Diagnostic[];
2295        getGlobalDiagnostics(cancellationToken?: CancellationToken): readonly Diagnostic[];
2296        getSyntacticDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly DiagnosticWithLocation[];
2297        /** The first time this is called, it will return global diagnostics (no location). */
2298        getSemanticDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly Diagnostic[];
2299        getSemanticDiagnosticsForLinter(sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly Diagnostic[];
2300        getDeclarationDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly DiagnosticWithLocation[];
2301        getConfigFileParsingDiagnostics(): readonly Diagnostic[];
2302        getEtsLibSFromProgram(): string[];
2303        /**
2304         * Gets a type checker that can be used to semantically analyze source files in the program.
2305         */
2306        getTypeChecker(): TypeChecker;
2307        /**
2308         * Gets a type checker that can be used to semantically analyze source files in the program for arkts linter.
2309         */
2310        getLinterTypeChecker(): TypeChecker;
2311        getNodeCount(): number;
2312        getIdentifierCount(): number;
2313        getSymbolCount(): number;
2314        getTypeCount(): number;
2315        getInstantiationCount(): number;
2316        getRelationCacheSizes(): {
2317            assignable: number;
2318            identity: number;
2319            subtype: number;
2320            strictSubtype: number;
2321        };
2322        isSourceFileFromExternalLibrary(file: SourceFile): boolean;
2323        isSourceFileDefaultLibrary(file: SourceFile): boolean;
2324        getSourceFileFromReference(referencingFile: SourceFile | UnparsedSource, ref: FileReference): SourceFile | undefined;
2325        getProjectReferences(): readonly ProjectReference[] | undefined;
2326        getResolvedProjectReferences(): readonly (ResolvedProjectReference | undefined)[] | undefined;
2327        getJsDocNodeCheckedConfig?(jsDocFileCheckInfo: FileCheckModuleInfo, symbolSourceFilePath: string): JsDocNodeCheckConfig;
2328        getJsDocNodeConditionCheckedResult?(jsDocFileCheckedInfo: FileCheckModuleInfo, jsDocs: JsDocTagInfo[]): ConditionCheckResult;
2329        getFileCheckedModuleInfo?(containFilePath: string): FileCheckModuleInfo;
2330        /**
2331         * Release typeChecker & linterTypeChecker
2332         */
2333        releaseTypeChecker(): void;
2334        getEmitHost(writeFileCallback?: WriteFileCallback): EmitHost;
2335        refreshTypeChecker(): void;
2336        setProgramSourceFiles(file: SourceFile): void;
2337        initProcessingFiles(): void;
2338        processImportedModules(file: SourceFile): void;
2339        getProcessingFiles(): SourceFile[] | undefined;
2340        deleteProgramSourceFiles(fileNames: string[]): void;
2341    }
2342    export type RedirectTargetsMap = ReadonlyESMap<Path, readonly string[]>;
2343    export interface ResolvedProjectReference {
2344        commandLine: ParsedCommandLine;
2345        sourceFile: SourceFile;
2346        references?: readonly (ResolvedProjectReference | undefined)[];
2347    }
2348    export type CustomTransformerFactory = (context: TransformationContext) => CustomTransformer;
2349    export interface CustomTransformer {
2350        transformSourceFile(node: SourceFile): SourceFile;
2351        transformBundle(node: Bundle): Bundle;
2352    }
2353    export interface CustomTransformers {
2354        /** Custom transformers to evaluate before built-in .js transformations. */
2355        before?: (TransformerFactory<SourceFile> | CustomTransformerFactory)[];
2356        /** Custom transformers to evaluate after built-in .js transformations. */
2357        after?: (TransformerFactory<SourceFile> | CustomTransformerFactory)[];
2358        /** Custom transformers to evaluate after built-in .d.ts transformations. */
2359        afterDeclarations?: (TransformerFactory<Bundle | SourceFile> | CustomTransformerFactory)[];
2360    }
2361    export interface SourceMapSpan {
2362        /** Line number in the .js file. */
2363        emittedLine: number;
2364        /** Column number in the .js file. */
2365        emittedColumn: number;
2366        /** Line number in the .ts file. */
2367        sourceLine: number;
2368        /** Column number in the .ts file. */
2369        sourceColumn: number;
2370        /** Optional name (index into names array) associated with this span. */
2371        nameIndex?: number;
2372        /** .ts file (index into sources array) associated with this span */
2373        sourceIndex: number;
2374    }
2375    /** Return code used by getEmitOutput function to indicate status of the function */
2376    export enum ExitStatus {
2377        Success = 0,
2378        DiagnosticsPresent_OutputsSkipped = 1,
2379        DiagnosticsPresent_OutputsGenerated = 2,
2380        InvalidProject_OutputsSkipped = 3,
2381        ProjectReferenceCycle_OutputsSkipped = 4,
2382        /** @deprecated Use ProjectReferenceCycle_OutputsSkipped instead. */
2383        ProjectReferenceCycle_OutputsSkupped = 4
2384    }
2385    export interface EmitResult {
2386        emitSkipped: boolean;
2387        /** Contains declaration emit diagnostics */
2388        diagnostics: readonly Diagnostic[];
2389        emittedFiles?: string[];
2390    }
2391    export interface TypeChecker {
2392        getTypeOfSymbolAtLocation(symbol: Symbol, node: Node): Type;
2393        getDeclaredTypeOfSymbol(symbol: Symbol): Type;
2394        getPropertiesOfType(type: Type): Symbol[];
2395        getPropertyOfType(type: Type, propertyName: string): Symbol | undefined;
2396        getPrivateIdentifierPropertyOfType(leftType: Type, name: string, location: Node): Symbol | undefined;
2397        getIndexInfoOfType(type: Type, kind: IndexKind): IndexInfo | undefined;
2398        getIndexInfosOfType(type: Type): readonly IndexInfo[];
2399        getIndexInfosOfIndexSymbol: (indexSymbol: Symbol) => IndexInfo[];
2400        getSignaturesOfType(type: Type, kind: SignatureKind): readonly Signature[];
2401        getIndexTypeOfType(type: Type, kind: IndexKind): Type | undefined;
2402        getBaseTypes(type: InterfaceType): BaseType[];
2403        getBaseTypeOfLiteralType(type: Type): Type;
2404        getWidenedType(type: Type): Type;
2405        getReturnTypeOfSignature(signature: Signature): Type;
2406        getNullableType(type: Type, flags: TypeFlags): Type;
2407        getNonNullableType(type: Type): Type;
2408        getTypeArguments(type: TypeReference): readonly Type[];
2409        /** Note that the resulting nodes cannot be checked. */
2410        typeToTypeNode(type: Type, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): TypeNode | undefined;
2411        /** Note that the resulting nodes cannot be checked. */
2412        signatureToSignatureDeclaration(signature: Signature, kind: SyntaxKind, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): SignatureDeclaration & {
2413            typeArguments?: NodeArray<TypeNode>;
2414        } | undefined;
2415        /** Note that the resulting nodes cannot be checked. */
2416        indexInfoToIndexSignatureDeclaration(indexInfo: IndexInfo, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): IndexSignatureDeclaration | undefined;
2417        /** Note that the resulting nodes cannot be checked. */
2418        symbolToEntityName(symbol: Symbol, meaning: SymbolFlags, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): EntityName | undefined;
2419        /** Note that the resulting nodes cannot be checked. */
2420        symbolToExpression(symbol: Symbol, meaning: SymbolFlags, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): Expression | undefined;
2421        /** Note that the resulting nodes cannot be checked. */
2422        symbolToTypeParameterDeclarations(symbol: Symbol, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): NodeArray<TypeParameterDeclaration> | undefined;
2423        /** Note that the resulting nodes cannot be checked. */
2424        symbolToParameterDeclaration(symbol: Symbol, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): ParameterDeclaration | undefined;
2425        /** Note that the resulting nodes cannot be checked. */
2426        typeParameterToDeclaration(parameter: TypeParameter, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): TypeParameterDeclaration | undefined;
2427        getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[];
2428        getSymbolAtLocation(node: Node): Symbol | undefined;
2429        getSymbolsOfParameterPropertyDeclaration(parameter: ParameterDeclaration, parameterName: string): Symbol[];
2430        /**
2431         * The function returns the value (local variable) symbol of an identifier in the short-hand property assignment.
2432         * This is necessary as an identifier in short-hand property assignment can contains two meaning: property name and property value.
2433         */
2434        getShorthandAssignmentValueSymbol(location: Node | undefined): Symbol | undefined;
2435        getExportSpecifierLocalTargetSymbol(location: ExportSpecifier | Identifier): Symbol | undefined;
2436        /**
2437         * If a symbol is a local symbol with an associated exported symbol, returns the exported symbol.
2438         * Otherwise returns its input.
2439         * For example, at `export type T = number;`:
2440         *     - `getSymbolAtLocation` at the location `T` will return the exported symbol for `T`.
2441         *     - But the result of `getSymbolsInScope` will contain the *local* symbol for `T`, not the exported symbol.
2442         *     - Calling `getExportSymbolOfSymbol` on that local symbol will return the exported symbol.
2443         */
2444        getExportSymbolOfSymbol(symbol: Symbol): Symbol;
2445        getPropertySymbolOfDestructuringAssignment(location: Identifier): Symbol | undefined;
2446        getTypeOfAssignmentPattern(pattern: AssignmentPattern): Type;
2447        getTypeAtLocation(node: Node): Type;
2448        tryGetTypeAtLocationWithoutCheck(node: Node): Type;
2449        getTypeFromTypeNode(node: TypeNode): Type;
2450        signatureToString(signature: Signature, enclosingDeclaration?: Node, flags?: TypeFormatFlags, kind?: SignatureKind): string;
2451        typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string;
2452        symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags): string;
2453        typePredicateToString(predicate: TypePredicate, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string;
2454        getFullyQualifiedName(symbol: Symbol): string;
2455        getAugmentedPropertiesOfType(type: Type): Symbol[];
2456        getRootSymbols(symbol: Symbol): readonly Symbol[];
2457        getSymbolOfExpando(node: Node, allowDeclaration: boolean): Symbol | undefined;
2458        getContextualType(node: Expression): Type | undefined;
2459        /**
2460         * returns unknownSignature in the case of an error.
2461         * returns undefined if the node is not valid.
2462         * @param argumentCount Apparent number of arguments, passed in case of a possibly incomplete call. This should come from an ArgumentListInfo. See `signatureHelp.ts`.
2463         */
2464        getResolvedSignature(node: CallLikeExpression, candidatesOutArray?: Signature[], argumentCount?: number): Signature | undefined;
2465        tryGetResolvedSignatureWithoutCheck(node: CallLikeExpression, candidatesOutArray?: Signature[], argumentCount?: number): Signature | undefined;
2466        getSignatureFromDeclaration(declaration: SignatureDeclaration): Signature | undefined;
2467        isImplementationOfOverload(node: SignatureDeclaration): boolean | undefined;
2468        isUndefinedSymbol(symbol: Symbol): boolean;
2469        isArgumentsSymbol(symbol: Symbol): boolean;
2470        isUnknownSymbol(symbol: Symbol): boolean;
2471        getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): string | number | undefined;
2472        isValidPropertyAccess(node: PropertyAccessExpression | QualifiedName | ImportTypeNode, propertyName: string): boolean;
2473        /** Follow all aliases to get the original symbol. */
2474        getAliasedSymbol(symbol: Symbol): Symbol;
2475        /** Follow a *single* alias to get the immediately aliased symbol. */
2476        getImmediateAliasedSymbol(symbol: Symbol): Symbol | undefined;
2477        getExportsOfModule(moduleSymbol: Symbol): Symbol[];
2478        getJsxIntrinsicTagNamesAt(location: Node): Symbol[];
2479        isOptionalParameter(node: ParameterDeclaration): boolean;
2480        getAmbientModules(): Symbol[];
2481        tryGetMemberInModuleExports(memberName: string, moduleSymbol: Symbol): Symbol | undefined;
2482        getApparentType(type: Type): Type;
2483        getBaseConstraintOfType(type: Type): Type | undefined;
2484        getDefaultFromTypeParameter(type: Type): Type | undefined;
2485        getTypePredicateOfSignature(signature: Signature): TypePredicate | undefined;
2486        /**
2487         * Depending on the operation performed, it may be appropriate to throw away the checker
2488         * if the cancellation token is triggered. Typically, if it is used for error checking
2489         * and the operation is cancelled, then it should be discarded, otherwise it is safe to keep.
2490         */
2491        runWithCancellationToken<T>(token: CancellationToken, cb: (checker: TypeChecker) => T): T;
2492        getConstEnumRelate?(): ESMap<string, ESMap<string, string>>;
2493        clearConstEnumRelate?(): void;
2494        deleteConstEnumRelate?(path: string): void;
2495    }
2496    export enum NodeBuilderFlags {
2497        None = 0,
2498        NoTruncation = 1,
2499        WriteArrayAsGenericType = 2,
2500        GenerateNamesForShadowedTypeParams = 4,
2501        UseStructuralFallback = 8,
2502        ForbidIndexedAccessSymbolReferences = 16,
2503        WriteTypeArgumentsOfSignature = 32,
2504        UseFullyQualifiedType = 64,
2505        UseOnlyExternalAliasing = 128,
2506        SuppressAnyReturnType = 256,
2507        WriteTypeParametersInQualifiedName = 512,
2508        MultilineObjectLiterals = 1024,
2509        WriteClassExpressionAsTypeLiteral = 2048,
2510        UseTypeOfFunction = 4096,
2511        OmitParameterModifiers = 8192,
2512        UseAliasDefinedOutsideCurrentScope = 16384,
2513        UseSingleQuotesForStringLiteralType = 268435456,
2514        NoTypeReduction = 536870912,
2515        OmitThisParameter = 33554432,
2516        AllowThisInObjectLiteral = 32768,
2517        AllowQualifiedNameInPlaceOfIdentifier = 65536,
2518        /** @deprecated AllowQualifedNameInPlaceOfIdentifier. Use AllowQualifiedNameInPlaceOfIdentifier instead. */
2519        AllowQualifedNameInPlaceOfIdentifier = 65536,
2520        AllowAnonymousIdentifier = 131072,
2521        AllowEmptyUnionOrIntersection = 262144,
2522        AllowEmptyTuple = 524288,
2523        AllowUniqueESSymbolType = 1048576,
2524        AllowEmptyIndexInfoType = 2097152,
2525        AllowNodeModulesRelativePaths = 67108864,
2526        IgnoreErrors = 70221824,
2527        InObjectTypeLiteral = 4194304,
2528        InTypeAlias = 8388608,
2529        InInitialEntityName = 16777216
2530    }
2531    export enum TypeFormatFlags {
2532        None = 0,
2533        NoTruncation = 1,
2534        WriteArrayAsGenericType = 2,
2535        UseStructuralFallback = 8,
2536        WriteTypeArgumentsOfSignature = 32,
2537        UseFullyQualifiedType = 64,
2538        SuppressAnyReturnType = 256,
2539        MultilineObjectLiterals = 1024,
2540        WriteClassExpressionAsTypeLiteral = 2048,
2541        UseTypeOfFunction = 4096,
2542        OmitParameterModifiers = 8192,
2543        UseAliasDefinedOutsideCurrentScope = 16384,
2544        UseSingleQuotesForStringLiteralType = 268435456,
2545        NoTypeReduction = 536870912,
2546        OmitThisParameter = 33554432,
2547        AllowUniqueESSymbolType = 1048576,
2548        AddUndefined = 131072,
2549        WriteArrowStyleSignature = 262144,
2550        InArrayType = 524288,
2551        InElementType = 2097152,
2552        InFirstTypeArgument = 4194304,
2553        InTypeAlias = 8388608,
2554        /** @deprecated */ WriteOwnNameForAnyLike = 0,
2555        NodeBuilderFlagsMask = 848330091
2556    }
2557    export enum SymbolFormatFlags {
2558        None = 0,
2559        WriteTypeParametersOrArguments = 1,
2560        UseOnlyExternalAliasing = 2,
2561        AllowAnyNodeKind = 4,
2562        UseAliasDefinedOutsideCurrentScope = 8,
2563    }
2564    interface SymbolWriter extends SymbolTracker {
2565        writeKeyword(text: string): void;
2566        writeOperator(text: string): void;
2567        writePunctuation(text: string): void;
2568        writeSpace(text: string): void;
2569        writeStringLiteral(text: string): void;
2570        writeParameter(text: string): void;
2571        writeProperty(text: string): void;
2572        writeSymbol(text: string, symbol: Symbol): void;
2573        writeLine(force?: boolean): void;
2574        increaseIndent(): void;
2575        decreaseIndent(): void;
2576        clear(): void;
2577    }
2578    export enum TypePredicateKind {
2579        This = 0,
2580        Identifier = 1,
2581        AssertsThis = 2,
2582        AssertsIdentifier = 3
2583    }
2584    export interface TypePredicateBase {
2585        kind: TypePredicateKind;
2586        type: Type | undefined;
2587    }
2588    export interface ThisTypePredicate extends TypePredicateBase {
2589        kind: TypePredicateKind.This;
2590        parameterName: undefined;
2591        parameterIndex: undefined;
2592        type: Type;
2593    }
2594    export interface IdentifierTypePredicate extends TypePredicateBase {
2595        kind: TypePredicateKind.Identifier;
2596        parameterName: string;
2597        parameterIndex: number;
2598        type: Type;
2599    }
2600    export interface AssertsThisTypePredicate extends TypePredicateBase {
2601        kind: TypePredicateKind.AssertsThis;
2602        parameterName: undefined;
2603        parameterIndex: undefined;
2604        type: Type | undefined;
2605    }
2606    export interface AssertsIdentifierTypePredicate extends TypePredicateBase {
2607        kind: TypePredicateKind.AssertsIdentifier;
2608        parameterName: string;
2609        parameterIndex: number;
2610        type: Type | undefined;
2611    }
2612    export type TypePredicate = ThisTypePredicate | IdentifierTypePredicate | AssertsThisTypePredicate | AssertsIdentifierTypePredicate;
2613    export enum SymbolFlags {
2614        None = 0,
2615        FunctionScopedVariable = 1,
2616        BlockScopedVariable = 2,
2617        Property = 4,
2618        EnumMember = 8,
2619        Function = 16,
2620        Class = 32,
2621        Interface = 64,
2622        ConstEnum = 128,
2623        RegularEnum = 256,
2624        ValueModule = 512,
2625        NamespaceModule = 1024,
2626        TypeLiteral = 2048,
2627        ObjectLiteral = 4096,
2628        Method = 8192,
2629        Constructor = 16384,
2630        GetAccessor = 32768,
2631        SetAccessor = 65536,
2632        Signature = 131072,
2633        TypeParameter = 262144,
2634        TypeAlias = 524288,
2635        ExportValue = 1048576,
2636        Alias = 2097152,
2637        Prototype = 4194304,
2638        ExportStar = 8388608,
2639        Optional = 16777216,
2640        Transient = 33554432,
2641        Assignment = 67108864,
2642        ModuleExports = 134217728,
2643        Enum = 384,
2644        Variable = 3,
2645        Value = 111551,
2646        Type = 788968,
2647        Namespace = 1920,
2648        Module = 1536,
2649        Accessor = 98304,
2650        FunctionScopedVariableExcludes = 111550,
2651        BlockScopedVariableExcludes = 111551,
2652        ParameterExcludes = 111551,
2653        PropertyExcludes = 0,
2654        EnumMemberExcludes = 900095,
2655        FunctionExcludes = 110991,
2656        ClassExcludes = 899503,
2657        InterfaceExcludes = 788872,
2658        RegularEnumExcludes = 899327,
2659        ConstEnumExcludes = 899967,
2660        ValueModuleExcludes = 110735,
2661        NamespaceModuleExcludes = 0,
2662        MethodExcludes = 103359,
2663        GetAccessorExcludes = 46015,
2664        SetAccessorExcludes = 78783,
2665        AccessorExcludes = 13247,
2666        TypeParameterExcludes = 526824,
2667        TypeAliasExcludes = 788968,
2668        AliasExcludes = 2097152,
2669        ModuleMember = 2623475,
2670        ExportHasLocal = 944,
2671        BlockScoped = 418,
2672        PropertyOrAccessor = 98308,
2673        ClassMember = 106500,
2674    }
2675    export interface Symbol {
2676        flags: SymbolFlags;
2677        escapedName: __String;
2678        declarations?: Declaration[];
2679        valueDeclaration?: Declaration;
2680        members?: SymbolTable;
2681        exports?: SymbolTable;
2682        globalExports?: SymbolTable;
2683        exportSymbol?: Symbol;
2684    }
2685    export enum InternalSymbolName {
2686        Call = "__call",
2687        Constructor = "__constructor",
2688        New = "__new",
2689        Index = "__index",
2690        ExportStar = "__export",
2691        Global = "__global",
2692        Missing = "__missing",
2693        Type = "__type",
2694        Object = "__object",
2695        JSXAttributes = "__jsxAttributes",
2696        Class = "__class",
2697        Function = "__function",
2698        Computed = "__computed",
2699        Resolving = "__resolving__",
2700        ExportEquals = "export=",
2701        Default = "default",
2702        This = "this"
2703    }
2704    /**
2705     * This represents a string whose leading underscore have been escaped by adding extra leading underscores.
2706     * The shape of this brand is rather unique compared to others we've used.
2707     * Instead of just an intersection of a string and an object, it is that union-ed
2708     * with an intersection of void and an object. This makes it wholly incompatible
2709     * with a normal string (which is good, it cannot be misused on assignment or on usage),
2710     * while still being comparable with a normal string via === (also good) and castable from a string.
2711     */
2712    export type __String = (string & {
2713        __escapedIdentifier: void;
2714    }) | (void & {
2715        __escapedIdentifier: void;
2716    }) | InternalSymbolName;
2717    /** ReadonlyMap where keys are `__String`s. */
2718    export interface ReadonlyUnderscoreEscapedMap<T> extends ReadonlyESMap<__String, T> {
2719    }
2720    /** Map where keys are `__String`s. */
2721    export interface UnderscoreEscapedMap<T> extends ESMap<__String, T>, ReadonlyUnderscoreEscapedMap<T> {
2722    }
2723    /** SymbolTable based on ES6 Map interface. */
2724    export type SymbolTable = UnderscoreEscapedMap<Symbol>;
2725    export enum TypeFlags {
2726        Any = 1,
2727        Unknown = 2,
2728        String = 4,
2729        Number = 8,
2730        Boolean = 16,
2731        Enum = 32,
2732        BigInt = 64,
2733        StringLiteral = 128,
2734        NumberLiteral = 256,
2735        BooleanLiteral = 512,
2736        EnumLiteral = 1024,
2737        BigIntLiteral = 2048,
2738        ESSymbol = 4096,
2739        UniqueESSymbol = 8192,
2740        Void = 16384,
2741        Undefined = 32768,
2742        Null = 65536,
2743        Never = 131072,
2744        TypeParameter = 262144,
2745        Object = 524288,
2746        Union = 1048576,
2747        Intersection = 2097152,
2748        Index = 4194304,
2749        IndexedAccess = 8388608,
2750        Conditional = 16777216,
2751        Substitution = 33554432,
2752        NonPrimitive = 67108864,
2753        TemplateLiteral = 134217728,
2754        StringMapping = 268435456,
2755        Literal = 2944,
2756        Unit = 109440,
2757        StringOrNumberLiteral = 384,
2758        PossiblyFalsy = 117724,
2759        StringLike = 402653316,
2760        NumberLike = 296,
2761        BigIntLike = 2112,
2762        BooleanLike = 528,
2763        EnumLike = 1056,
2764        ESSymbolLike = 12288,
2765        VoidLike = 49152,
2766        UnionOrIntersection = 3145728,
2767        StructuredType = 3670016,
2768        TypeVariable = 8650752,
2769        InstantiableNonPrimitive = 58982400,
2770        InstantiablePrimitive = 406847488,
2771        Instantiable = 465829888,
2772        StructuredOrInstantiable = 469499904,
2773        Narrowable = 536624127,
2774    }
2775    export type DestructuringPattern = BindingPattern | ObjectLiteralExpression | ArrayLiteralExpression;
2776    export interface Type {
2777        flags: TypeFlags;
2778        symbol: Symbol;
2779        pattern?: DestructuringPattern;
2780        aliasSymbol?: Symbol;
2781        aliasTypeArguments?: readonly Type[];
2782    }
2783    export interface LiteralType extends Type {
2784        value: string | number | PseudoBigInt;
2785        freshType: LiteralType;
2786        regularType: LiteralType;
2787    }
2788    export interface UniqueESSymbolType extends Type {
2789        symbol: Symbol;
2790        escapedName: __String;
2791    }
2792    export interface StringLiteralType extends LiteralType {
2793        value: string;
2794    }
2795    export interface NumberLiteralType extends LiteralType {
2796        value: number;
2797    }
2798    export interface BigIntLiteralType extends LiteralType {
2799        value: PseudoBigInt;
2800    }
2801    export interface EnumType extends Type {
2802    }
2803    export enum ObjectFlags {
2804        Class = 1,
2805        Interface = 2,
2806        Reference = 4,
2807        Tuple = 8,
2808        Anonymous = 16,
2809        Mapped = 32,
2810        Instantiated = 64,
2811        ObjectLiteral = 128,
2812        EvolvingArray = 256,
2813        ObjectLiteralPatternWithComputedProperties = 512,
2814        ReverseMapped = 1024,
2815        JsxAttributes = 2048,
2816        JSLiteral = 4096,
2817        FreshLiteral = 8192,
2818        ArrayLiteral = 16384,
2819        ClassOrInterface = 3,
2820        ContainsSpread = 2097152,
2821        ObjectRestType = 4194304,
2822        InstantiationExpressionType = 8388608,
2823    }
2824    export interface ObjectType extends Type {
2825        objectFlags: ObjectFlags;
2826    }
2827    /** Class and interface types (ObjectFlags.Class and ObjectFlags.Interface). */
2828    export interface InterfaceType extends ObjectType {
2829        typeParameters: TypeParameter[] | undefined;
2830        outerTypeParameters: TypeParameter[] | undefined;
2831        localTypeParameters: TypeParameter[] | undefined;
2832        thisType: TypeParameter | undefined;
2833    }
2834    export type BaseType = ObjectType | IntersectionType | TypeVariable;
2835    export interface InterfaceTypeWithDeclaredMembers extends InterfaceType {
2836        declaredProperties: Symbol[];
2837        declaredCallSignatures: Signature[];
2838        declaredConstructSignatures: Signature[];
2839        declaredIndexInfos: IndexInfo[];
2840    }
2841    /**
2842     * Type references (ObjectFlags.Reference). When a class or interface has type parameters or
2843     * a "this" type, references to the class or interface are made using type references. The
2844     * typeArguments property specifies the types to substitute for the type parameters of the
2845     * class or interface and optionally includes an extra element that specifies the type to
2846     * substitute for "this" in the resulting instantiation. When no extra argument is present,
2847     * the type reference itself is substituted for "this". The typeArguments property is undefined
2848     * if the class or interface has no type parameters and the reference isn't specifying an
2849     * explicit "this" argument.
2850     */
2851    export interface TypeReference extends ObjectType {
2852        target: GenericType;
2853        node?: TypeReferenceNode | ArrayTypeNode | TupleTypeNode;
2854    }
2855    export interface DeferredTypeReference extends TypeReference {
2856    }
2857    export interface GenericType extends InterfaceType, TypeReference {
2858    }
2859    export enum ElementFlags {
2860        Required = 1,
2861        Optional = 2,
2862        Rest = 4,
2863        Variadic = 8,
2864        Fixed = 3,
2865        Variable = 12,
2866        NonRequired = 14,
2867        NonRest = 11
2868    }
2869    export interface TupleType extends GenericType {
2870        elementFlags: readonly ElementFlags[];
2871        minLength: number;
2872        fixedLength: number;
2873        hasRestElement: boolean;
2874        combinedFlags: ElementFlags;
2875        readonly: boolean;
2876        labeledElementDeclarations?: readonly (NamedTupleMember | ParameterDeclaration)[];
2877    }
2878    export interface TupleTypeReference extends TypeReference {
2879        target: TupleType;
2880    }
2881    export interface UnionOrIntersectionType extends Type {
2882        types: Type[];
2883    }
2884    export interface UnionType extends UnionOrIntersectionType {
2885    }
2886    export interface IntersectionType extends UnionOrIntersectionType {
2887    }
2888    export type StructuredType = ObjectType | UnionType | IntersectionType;
2889    export interface EvolvingArrayType extends ObjectType {
2890        elementType: Type;
2891        finalArrayType?: Type;
2892    }
2893    export interface InstantiableType extends Type {
2894    }
2895    export interface TypeParameter extends InstantiableType {
2896    }
2897    export interface IndexedAccessType extends InstantiableType {
2898        objectType: Type;
2899        indexType: Type;
2900        constraint?: Type;
2901        simplifiedForReading?: Type;
2902        simplifiedForWriting?: Type;
2903    }
2904    export type TypeVariable = TypeParameter | IndexedAccessType;
2905    export interface IndexType extends InstantiableType {
2906        type: InstantiableType | UnionOrIntersectionType;
2907    }
2908    export interface ConditionalRoot {
2909        node: ConditionalTypeNode;
2910        checkType: Type;
2911        extendsType: Type;
2912        isDistributive: boolean;
2913        inferTypeParameters?: TypeParameter[];
2914        outerTypeParameters?: TypeParameter[];
2915        instantiations?: Map<Type>;
2916        aliasSymbol?: Symbol;
2917        aliasTypeArguments?: Type[];
2918    }
2919    export interface ConditionalType extends InstantiableType {
2920        root: ConditionalRoot;
2921        checkType: Type;
2922        extendsType: Type;
2923        resolvedTrueType?: Type;
2924        resolvedFalseType?: Type;
2925    }
2926    export interface TemplateLiteralType extends InstantiableType {
2927        texts: readonly string[];
2928        types: readonly Type[];
2929    }
2930    export interface StringMappingType extends InstantiableType {
2931        symbol: Symbol;
2932        type: Type;
2933    }
2934    export interface SubstitutionType extends InstantiableType {
2935        objectFlags: ObjectFlags;
2936        baseType: Type;
2937        constraint: Type;
2938    }
2939    export enum SignatureKind {
2940        Call = 0,
2941        Construct = 1
2942    }
2943    export interface Signature {
2944        declaration?: SignatureDeclaration | JSDocSignature;
2945        typeParameters?: readonly TypeParameter[];
2946        parameters: readonly Symbol[];
2947    }
2948    export enum IndexKind {
2949        String = 0,
2950        Number = 1
2951    }
2952    export interface IndexInfo {
2953        keyType: Type;
2954        type: Type;
2955        isReadonly: boolean;
2956        declaration?: IndexSignatureDeclaration;
2957    }
2958    export enum InferencePriority {
2959        NakedTypeVariable = 1,
2960        SpeculativeTuple = 2,
2961        SubstituteSource = 4,
2962        HomomorphicMappedType = 8,
2963        PartialHomomorphicMappedType = 16,
2964        MappedTypeConstraint = 32,
2965        ContravariantConditional = 64,
2966        ReturnType = 128,
2967        LiteralKeyof = 256,
2968        NoConstraints = 512,
2969        AlwaysStrict = 1024,
2970        MaxValue = 2048,
2971        PriorityImpliesCombination = 416,
2972        Circularity = -1
2973    }
2974    /** @deprecated Use FileExtensionInfo instead. */
2975    export type JsFileExtensionInfo = FileExtensionInfo;
2976    export interface FileExtensionInfo {
2977        extension: string;
2978        isMixedContent: boolean;
2979        scriptKind?: ScriptKind;
2980    }
2981    export interface DiagnosticMessage {
2982        key: string;
2983        category: DiagnosticCategory;
2984        code: number;
2985        message: string;
2986        reportsUnnecessary?: {};
2987        reportsDeprecated?: {};
2988    }
2989    /**
2990     * A linked list of formatted diagnostic messages to be used as part of a multiline message.
2991     * It is built from the bottom up, leaving the head to be the "main" diagnostic.
2992     * While it seems that DiagnosticMessageChain is structurally similar to DiagnosticMessage,
2993     * the difference is that messages are all preformatted in DMC.
2994     */
2995    export interface DiagnosticMessageChain {
2996        messageText: string;
2997        category: DiagnosticCategory;
2998        code: number;
2999        next?: DiagnosticMessageChain[];
3000    }
3001    export interface Diagnostic extends DiagnosticRelatedInformation {
3002        /** May store more in future. For now, this will simply be `true` to indicate when a diagnostic is an unused-identifier diagnostic. */
3003        reportsUnnecessary?: {};
3004        reportsDeprecated?: {};
3005        source?: string;
3006        relatedInformation?: DiagnosticRelatedInformation[];
3007    }
3008    export interface DiagnosticRelatedInformation {
3009        category: DiagnosticCategory;
3010        code: number;
3011        file: SourceFile | undefined;
3012        start: number | undefined;
3013        length: number | undefined;
3014        messageText: string | DiagnosticMessageChain;
3015    }
3016    export interface DiagnosticWithLocation extends Diagnostic {
3017        file: SourceFile;
3018        start: number;
3019        length: number;
3020    }
3021    export enum DiagnosticCategory {
3022        Warning = 0,
3023        Error = 1,
3024        Suggestion = 2,
3025        Message = 3
3026    }
3027    export enum ModuleResolutionKind {
3028        Classic = 1,
3029        NodeJs = 2,
3030        Node16 = 3,
3031        NodeNext = 99
3032    }
3033    export enum ModuleDetectionKind {
3034        /**
3035         * Files with imports, exports and/or import.meta are considered modules
3036         */
3037        Legacy = 1,
3038        /**
3039         * Legacy, but also files with jsx under react-jsx or react-jsxdev and esm mode files under moduleResolution: node16+
3040         */
3041        Auto = 2,
3042        /**
3043         * Consider all non-declaration files modules, regardless of present syntax
3044         */
3045        Force = 3
3046    }
3047    export interface PluginImport {
3048        name: string;
3049    }
3050    export interface ProjectReference {
3051        /** A normalized path on disk */
3052        path: string;
3053        /** The path as the user originally wrote it */
3054        originalPath?: string;
3055        /** True if the output of this reference should be prepended to the output of this project. Only valid for --outFile compilations */
3056        prepend?: boolean;
3057        /** True if it is intended that this reference form a circularity */
3058        circular?: boolean;
3059    }
3060    export enum WatchFileKind {
3061        FixedPollingInterval = 0,
3062        PriorityPollingInterval = 1,
3063        DynamicPriorityPolling = 2,
3064        FixedChunkSizePolling = 3,
3065        UseFsEvents = 4,
3066        UseFsEventsOnParentDirectory = 5
3067    }
3068    export enum WatchDirectoryKind {
3069        UseFsEvents = 0,
3070        FixedPollingInterval = 1,
3071        DynamicPriorityPolling = 2,
3072        FixedChunkSizePolling = 3
3073    }
3074    export enum PollingWatchKind {
3075        FixedInterval = 0,
3076        PriorityInterval = 1,
3077        DynamicPriority = 2,
3078        FixedChunkSize = 3
3079    }
3080    export type CompilerOptionsValue = string | number | boolean | (string | number)[] | string[] | MapLike<string[]> | PluginImport[] | ProjectReference[] | null | undefined | EtsOptions;
3081    export interface CompilerOptions {
3082        allowJs?: boolean;
3083        allowSyntheticDefaultImports?: boolean;
3084        allowUmdGlobalAccess?: boolean;
3085        allowUnreachableCode?: boolean;
3086        allowUnusedLabels?: boolean;
3087        alwaysStrict?: boolean;
3088        baseUrl?: string;
3089        charset?: string;
3090        checkJs?: boolean;
3091        declaration?: boolean;
3092        declarationMap?: boolean;
3093        emitDeclarationOnly?: boolean;
3094        declarationDir?: string;
3095        disableSizeLimit?: boolean;
3096        disableSourceOfProjectReferenceRedirect?: boolean;
3097        disableSolutionSearching?: boolean;
3098        disableReferencedProjectLoad?: boolean;
3099        downlevelIteration?: boolean;
3100        emitBOM?: boolean;
3101        emitDecoratorMetadata?: boolean;
3102        exactOptionalPropertyTypes?: boolean;
3103        experimentalDecorators?: boolean;
3104        forceConsistentCasingInFileNames?: boolean;
3105        importHelpers?: boolean;
3106        importsNotUsedAsValues?: ImportsNotUsedAsValues;
3107        inlineSourceMap?: boolean;
3108        inlineSources?: boolean;
3109        isolatedModules?: boolean;
3110        jsx?: JsxEmit;
3111        keyofStringsOnly?: boolean;
3112        lib?: string[];
3113        locale?: string;
3114        mapRoot?: string;
3115        maxNodeModuleJsDepth?: number;
3116        module?: ModuleKind;
3117        moduleResolution?: ModuleResolutionKind;
3118        moduleSuffixes?: string[];
3119        moduleDetection?: ModuleDetectionKind;
3120        newLine?: NewLineKind;
3121        noEmit?: boolean;
3122        noEmitHelpers?: boolean;
3123        noEmitOnError?: boolean;
3124        noErrorTruncation?: boolean;
3125        noFallthroughCasesInSwitch?: boolean;
3126        noImplicitAny?: boolean;
3127        noImplicitReturns?: boolean;
3128        noImplicitThis?: boolean;
3129        noStrictGenericChecks?: boolean;
3130        noUnusedLocals?: boolean;
3131        noUnusedParameters?: boolean;
3132        noImplicitUseStrict?: boolean;
3133        noPropertyAccessFromIndexSignature?: boolean;
3134        assumeChangesOnlyAffectDirectDependencies?: boolean;
3135        noLib?: boolean;
3136        noResolve?: boolean;
3137        noUncheckedIndexedAccess?: boolean;
3138        out?: string;
3139        outDir?: string;
3140        outFile?: string;
3141        paths?: MapLike<string[]>;
3142        preserveConstEnums?: boolean;
3143        noImplicitOverride?: boolean;
3144        preserveSymlinks?: boolean;
3145        preserveValueImports?: boolean;
3146        project?: string;
3147        reactNamespace?: string;
3148        jsxFactory?: string;
3149        jsxFragmentFactory?: string;
3150        jsxImportSource?: string;
3151        composite?: boolean;
3152        incremental?: boolean;
3153        tsBuildInfoFile?: string;
3154        removeComments?: boolean;
3155        rootDir?: string;
3156        rootDirs?: string[];
3157        skipLibCheck?: boolean;
3158        skipDefaultLibCheck?: boolean;
3159        sourceMap?: boolean;
3160        sourceRoot?: string;
3161        strict?: boolean;
3162        strictFunctionTypes?: boolean;
3163        strictBindCallApply?: boolean;
3164        strictNullChecks?: boolean;
3165        strictPropertyInitialization?: boolean;
3166        stripInternal?: boolean;
3167        suppressExcessPropertyErrors?: boolean;
3168        suppressImplicitAnyIndexErrors?: boolean;
3169        target?: ScriptTarget;
3170        traceResolution?: boolean;
3171        useUnknownInCatchVariables?: boolean;
3172        resolveJsonModule?: boolean;
3173        types?: string[];
3174        /** Paths used to compute primary types search locations */
3175        typeRoots?: string[];
3176        esModuleInterop?: boolean;
3177        useDefineForClassFields?: boolean;
3178        ets?: EtsOptions;
3179        packageManagerType?: string;
3180        emitNodeModulesFiles?: boolean;
3181        etsLoaderPath?: string;
3182        tsImportSendableEnable?: boolean;
3183        skipPathsInKeyForCompilationSettings?: boolean;
3184        compatibleSdkVersion?: number;
3185        compatibleSdkVersionStage?: string;
3186        [option: string]: CompilerOptionsValue | TsConfigSourceFile | undefined;
3187    }
3188    export interface EtsOptions {
3189        render: {
3190            method: string[];
3191            decorator: string[];
3192        };
3193        components: string[];
3194        libs: string[];
3195        extend: {
3196            decorator: string[];
3197            components: {
3198                name: string;
3199                type: string;
3200                instance: string;
3201            }[];
3202        };
3203        styles: {
3204            decorator: string;
3205            component: {
3206                name: string;
3207                type: string;
3208                instance: string;
3209            };
3210            property: string;
3211        };
3212        concurrent: {
3213            decorator: string;
3214        };
3215        customComponent?: string;
3216        propertyDecorators: {
3217            name: string;
3218            needInitialization: boolean;
3219        }[];
3220        emitDecorators: {
3221            name: string;
3222            emitParameters: boolean;
3223        }[];
3224        syntaxComponents: {
3225            paramsUICallback: string[];
3226            attrUICallback: {
3227                name: string;
3228                attributes: string[];
3229            }[];
3230        };
3231    }
3232    export interface WatchOptions {
3233        watchFile?: WatchFileKind;
3234        watchDirectory?: WatchDirectoryKind;
3235        fallbackPolling?: PollingWatchKind;
3236        synchronousWatchDirectory?: boolean;
3237        excludeDirectories?: string[];
3238        excludeFiles?: string[];
3239        [option: string]: CompilerOptionsValue | undefined;
3240    }
3241    export interface TypeAcquisition {
3242        /**
3243         * @deprecated typingOptions.enableAutoDiscovery
3244         * Use typeAcquisition.enable instead.
3245         */
3246        enableAutoDiscovery?: boolean;
3247        enable?: boolean;
3248        include?: string[];
3249        exclude?: string[];
3250        disableFilenameBasedTypeAcquisition?: boolean;
3251        [option: string]: CompilerOptionsValue | undefined;
3252    }
3253    export enum ModuleKind {
3254        None = 0,
3255        CommonJS = 1,
3256        AMD = 2,
3257        UMD = 3,
3258        System = 4,
3259        ES2015 = 5,
3260        ES2020 = 6,
3261        ES2022 = 7,
3262        ESNext = 99,
3263        Node16 = 100,
3264        NodeNext = 199
3265    }
3266    export enum JsxEmit {
3267        None = 0,
3268        Preserve = 1,
3269        React = 2,
3270        ReactNative = 3,
3271        ReactJSX = 4,
3272        ReactJSXDev = 5
3273    }
3274    export enum ImportsNotUsedAsValues {
3275        Remove = 0,
3276        Preserve = 1,
3277        Error = 2
3278    }
3279    export enum NewLineKind {
3280        CarriageReturnLineFeed = 0,
3281        LineFeed = 1
3282    }
3283    export interface LineAndCharacter {
3284        /** 0-based. */
3285        line: number;
3286        character: number;
3287    }
3288    export enum ScriptKind {
3289        Unknown = 0,
3290        JS = 1,
3291        JSX = 2,
3292        TS = 3,
3293        TSX = 4,
3294        External = 5,
3295        JSON = 6,
3296        /**
3297         * Used on extensions that doesn't define the ScriptKind but the content defines it.
3298         * Deferred extensions are going to be included in all project contexts.
3299         */
3300        Deferred = 7,
3301        ETS = 8
3302    }
3303    export enum ScriptTarget {
3304        ES3 = 0,
3305        ES5 = 1,
3306        ES2015 = 2,
3307        ES2016 = 3,
3308        ES2017 = 4,
3309        ES2018 = 5,
3310        ES2019 = 6,
3311        ES2020 = 7,
3312        ES2021 = 8,
3313        ES2022 = 9,
3314        ESNext = 99,
3315        JSON = 100,
3316        Latest = 99
3317    }
3318    export enum LanguageVariant {
3319        Standard = 0,
3320        JSX = 1
3321    }
3322    /** Either a parsed command line or a parsed tsconfig.json */
3323    export interface ParsedCommandLine {
3324        options: CompilerOptions;
3325        typeAcquisition?: TypeAcquisition;
3326        fileNames: string[];
3327        projectReferences?: readonly ProjectReference[];
3328        watchOptions?: WatchOptions;
3329        raw?: any;
3330        errors: Diagnostic[];
3331        wildcardDirectories?: MapLike<WatchDirectoryFlags>;
3332        compileOnSave?: boolean;
3333    }
3334    export enum WatchDirectoryFlags {
3335        None = 0,
3336        Recursive = 1
3337    }
3338    export interface CreateProgramOptions {
3339        rootNames: readonly string[];
3340        options: CompilerOptions;
3341        projectReferences?: readonly ProjectReference[];
3342        host?: CompilerHost;
3343        oldProgram?: Program;
3344        configFileParsingDiagnostics?: readonly Diagnostic[];
3345    }
3346    export interface ModuleResolutionHost {
3347        fileExists(fileName: string): boolean;
3348        readFile(fileName: string): string | undefined;
3349        trace?(s: string): void;
3350        directoryExists?(directoryName: string): boolean;
3351        /**
3352         * Resolve a symbolic link.
3353         * @see https://nodejs.org/api/fs.html#fs_fs_realpathsync_path_options
3354         */
3355        realpath?(path: string): string;
3356        getCurrentDirectory?(): string;
3357        getDirectories?(path: string): string[];
3358        useCaseSensitiveFileNames?: boolean | (() => boolean) | undefined;
3359        getJsDocNodeCheckedConfig?(jsDocFileCheckInfo: FileCheckModuleInfo, symbolSourceFilePath: string): JsDocNodeCheckConfig;
3360        getJsDocNodeConditionCheckedResult?(jsDocFileCheckedInfo: FileCheckModuleInfo, jsDocs: JsDocTagInfo[]): ConditionCheckResult;
3361        getFileCheckedModuleInfo?(containFilePath: string): FileCheckModuleInfo;
3362    }
3363    /**
3364     * Used by services to specify the minimum host area required to set up source files under any compilation settings
3365     */
3366    export interface MinimalResolutionCacheHost extends ModuleResolutionHost {
3367        getCompilationSettings(): CompilerOptions;
3368        getCompilerHost?(): CompilerHost | undefined;
3369    }
3370    /**
3371     * Represents the result of module resolution.
3372     * Module resolution will pick up tsx/jsx/js files even if '--jsx' and '--allowJs' are turned off.
3373     * The Program will then filter results based on these flags.
3374     *
3375     * Prefer to return a `ResolvedModuleFull` so that the file type does not have to be inferred.
3376     */
3377    export interface ResolvedModule {
3378        /** Path of the file the module was resolved to. */
3379        resolvedFileName: string;
3380        /** True if `resolvedFileName` comes from `node_modules`. */
3381        isExternalLibraryImport?: boolean;
3382    }
3383    /**
3384     * ResolvedModule with an explicitly provided `extension` property.
3385     * Prefer this over `ResolvedModule`.
3386     * If changing this, remember to change `moduleResolutionIsEqualTo`.
3387     */
3388    export interface ResolvedModuleFull extends ResolvedModule {
3389        /**
3390         * Extension of resolvedFileName. This must match what's at the end of resolvedFileName.
3391         * This is optional for backwards-compatibility, but will be added if not provided.
3392         */
3393        extension: Extension;
3394        packageId?: PackageId;
3395    }
3396    /**
3397     * Unique identifier with a package name and version.
3398     * If changing this, remember to change `packageIdIsEqual`.
3399     */
3400    export interface PackageId {
3401        /**
3402         * Name of the package.
3403         * Should not include `@types`.
3404         * If accessing a non-index file, this should include its name e.g. "foo/bar".
3405         */
3406        name: string;
3407        /**
3408         * Name of a submodule within this package.
3409         * May be "".
3410         */
3411        subModuleName: string;
3412        /** Version of the package, e.g. "1.2.3" */
3413        version: string;
3414    }
3415    export enum Extension {
3416        Ts = ".ts",
3417        Tsx = ".tsx",
3418        Dts = ".d.ts",
3419        Js = ".js",
3420        Jsx = ".jsx",
3421        Json = ".json",
3422        TsBuildInfo = ".tsbuildinfo",
3423        Mjs = ".mjs",
3424        Mts = ".mts",
3425        Dmts = ".d.mts",
3426        Cjs = ".cjs",
3427        Cts = ".cts",
3428        Dcts = ".d.cts",
3429        Ets = ".ets",
3430        Dets = ".d.ets"
3431    }
3432    export interface ResolvedModuleWithFailedLookupLocations {
3433        readonly resolvedModule: ResolvedModuleFull | undefined;
3434    }
3435    export interface ResolvedTypeReferenceDirective {
3436        primary: boolean;
3437        resolvedFileName: string | undefined;
3438        packageId?: PackageId;
3439        /** True if `resolvedFileName` comes from `node_modules` or `oh_modules`. */
3440        isExternalLibraryImport?: boolean;
3441    }
3442    export interface ResolvedTypeReferenceDirectiveWithFailedLookupLocations {
3443        readonly resolvedTypeReferenceDirective: ResolvedTypeReferenceDirective | undefined;
3444        readonly failedLookupLocations: string[];
3445    }
3446    export interface FileCheckModuleInfo {
3447        fileNeedCheck: boolean;
3448        checkPayload: any;
3449        currentFileName: string;
3450    }
3451    export interface JsDocNodeCheckConfig {
3452        nodeNeedCheck: boolean;
3453        checkConfig: JsDocNodeCheckConfigItem[];
3454    }
3455    export interface JsDocNodeCheckConfigItem {
3456        tagName: string[];
3457        message: string;
3458        needConditionCheck: boolean;
3459        type: DiagnosticCategory;
3460        specifyCheckConditionFuncName: string;
3461        tagNameShouldExisted: boolean;
3462        checkValidCallback?: (jsDocTag: JSDocTag, config: JsDocNodeCheckConfigItem) => boolean;
3463        checkJsDocSpecialValidCallback?: (jsDocTags: readonly JSDocTag[], config: JsDocNodeCheckConfigItem) => boolean;
3464    }
3465    export interface TagCheckParam {
3466        needCheck: boolean;
3467        checkConfig: TagCheckConfig[];
3468    }
3469    export interface TagCheckConfig {
3470        tagName: string;
3471        message: string;
3472        needConditionCheck: boolean;
3473        specifyCheckConditionFuncName: string;
3474    }
3475    export interface ConditionCheckResult {
3476        valid: boolean;
3477        type?: DiagnosticCategory;
3478        message?: string;
3479    }
3480    export interface CompilerHost extends ModuleResolutionHost {
3481        getSourceFile(fileName: string, languageVersionOrOptions: ScriptTarget | CreateSourceFileOptions, onError?: (message: string) => void, shouldCreateNewSourceFile?: boolean): SourceFile | undefined;
3482        getSourceFileByPath?(fileName: string, path: Path, languageVersionOrOptions: ScriptTarget | CreateSourceFileOptions, onError?: (message: string) => void, shouldCreateNewSourceFile?: boolean): SourceFile | undefined;
3483        getCancellationToken?(): CancellationToken;
3484        getDefaultLibFileName(options: CompilerOptions): string;
3485        getDefaultLibLocation?(): string;
3486        writeFile: WriteFileCallback;
3487        getCurrentDirectory(): string;
3488        getCanonicalFileName(fileName: string): string;
3489        useCaseSensitiveFileNames(): boolean;
3490        getNewLine(): string;
3491        readDirectory?(rootDir: string, extensions: readonly string[], excludes: readonly string[] | undefined, includes: readonly string[], depth?: number): string[];
3492        resolveModuleNames?(moduleNames: string[], containingFile: string, reusedNames: string[] | undefined, redirectedReference: ResolvedProjectReference | undefined, options: CompilerOptions, containingSourceFile?: SourceFile): (ResolvedModule | undefined)[];
3493        /**
3494         * 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
3495         */
3496        getModuleResolutionCache?(): ModuleResolutionCache | undefined;
3497        /**
3498         * This method is a companion for 'resolveModuleNames' and is used to resolve 'types' references to actual type declaration files
3499         */
3500        resolveTypeReferenceDirectives?(typeReferenceDirectiveNames: string[] | readonly FileReference[], containingFile: string, redirectedReference: ResolvedProjectReference | undefined, options: CompilerOptions, containingFileMode?: SourceFile["impliedNodeFormat"] | undefined): (ResolvedTypeReferenceDirective | undefined)[];
3501        getEnvironmentVariable?(name: string): string | undefined;
3502        /** If provided along with custom resolveModuleNames or resolveTypeReferenceDirectives, used to determine if unchanged file path needs to re-resolve modules/type reference directives */
3503        hasInvalidatedResolutions?(filePath: Path): boolean;
3504        createHash?(data: string): string;
3505        getParsedCommandLine?(fileName: string): ParsedCommandLine | undefined;
3506        /**
3507         * get tagName where need to be determined based on the file path
3508         * @param jsDocFileCheckInfo filePath
3509         * @param symbolSourceFilePath filePath
3510         */
3511        getJsDocNodeCheckedConfig?(jsDocFileCheckInfo: FileCheckModuleInfo, symbolSourceFilePath: string): JsDocNodeCheckConfig;
3512        /**
3513         * get checked results based on the file path and jsDocs
3514         * @param jsDocFileCheckedInfo
3515         * @param jsDocs
3516         */
3517        getJsDocNodeConditionCheckedResult?(jsDocFileCheckedInfo: FileCheckModuleInfo, jsDocs: JsDocTagInfo[]): ConditionCheckResult;
3518        getFileCheckedModuleInfo?(containFilePath: string): FileCheckModuleInfo;
3519        getLastCompiledProgram?(): Program;
3520    }
3521    export interface SourceMapRange extends TextRange {
3522        source?: SourceMapSource;
3523    }
3524    export interface SourceMapSource {
3525        fileName: string;
3526        text: string;
3527        skipTrivia?: (pos: number) => number;
3528    }
3529    export enum EmitFlags {
3530        None = 0,
3531        SingleLine = 1,
3532        AdviseOnEmitNode = 2,
3533        NoSubstitution = 4,
3534        CapturesThis = 8,
3535        NoLeadingSourceMap = 16,
3536        NoTrailingSourceMap = 32,
3537        NoSourceMap = 48,
3538        NoNestedSourceMaps = 64,
3539        NoTokenLeadingSourceMaps = 128,
3540        NoTokenTrailingSourceMaps = 256,
3541        NoTokenSourceMaps = 384,
3542        NoLeadingComments = 512,
3543        NoTrailingComments = 1024,
3544        NoComments = 1536,
3545        NoNestedComments = 2048,
3546        HelperName = 4096,
3547        ExportName = 8192,
3548        LocalName = 16384,
3549        InternalName = 32768,
3550        Indented = 65536,
3551        NoIndentation = 131072,
3552        AsyncFunctionBody = 262144,
3553        ReuseTempVariableScope = 524288,
3554        CustomPrologue = 1048576,
3555        NoHoisting = 2097152,
3556        HasEndOfDeclarationMarker = 4194304,
3557        Iterator = 8388608,
3558        NoAsciiEscaping = 16777216,
3559    }
3560    export interface EmitHelperBase {
3561        readonly name: string;
3562        readonly scoped: boolean;
3563        readonly text: string | ((node: EmitHelperUniqueNameCallback) => string);
3564        readonly priority?: number;
3565        readonly dependencies?: EmitHelper[];
3566    }
3567    export interface ScopedEmitHelper extends EmitHelperBase {
3568        readonly scoped: true;
3569    }
3570    export interface UnscopedEmitHelper extends EmitHelperBase {
3571        readonly scoped: false;
3572        readonly text: string;
3573    }
3574    export type EmitHelper = ScopedEmitHelper | UnscopedEmitHelper;
3575    export type EmitHelperUniqueNameCallback = (name: string) => string;
3576    export enum EmitHint {
3577        SourceFile = 0,
3578        Expression = 1,
3579        IdentifierName = 2,
3580        MappedTypeParameter = 3,
3581        Unspecified = 4,
3582        EmbeddedStatement = 5,
3583        JsxAttributeValue = 6
3584    }
3585    export interface SourceFileMayBeEmittedHost {
3586        getCompilerOptions(): CompilerOptions;
3587        isSourceFileFromExternalLibrary(file: SourceFile): boolean;
3588        getResolvedProjectReferenceToRedirect(fileName: string): ResolvedProjectReference | undefined;
3589        isSourceOfProjectReferenceRedirect(fileName: string): boolean;
3590    }
3591    export interface EmitHost extends ScriptReferenceHost, ModuleSpecifierResolutionHost, SourceFileMayBeEmittedHost {
3592        getSourceFiles(): readonly SourceFile[];
3593        useCaseSensitiveFileNames(): boolean;
3594        getCurrentDirectory(): string;
3595        getLibFileFromReference(ref: FileReference): SourceFile | undefined;
3596        getCommonSourceDirectory(): string;
3597        getCanonicalFileName(fileName: string): string;
3598        getNewLine(): string;
3599        isEmitBlocked(emitFileName: string): boolean;
3600        getPrependNodes(): readonly (InputFiles | UnparsedSource)[];
3601        writeFile: WriteFileCallback;
3602        getSourceFileFromReference: Program["getSourceFileFromReference"];
3603        readonly redirectTargetsMap: RedirectTargetsMap;
3604        createHash?(data: string): string;
3605    }
3606    export enum OuterExpressionKinds {
3607        Parentheses = 1,
3608        TypeAssertions = 2,
3609        NonNullAssertions = 4,
3610        PartiallyEmittedExpressions = 8,
3611        Assertions = 6,
3612        All = 15,
3613        ExcludeJSDocTypeAssertion = 16
3614    }
3615    export type TypeOfTag = "undefined" | "number" | "bigint" | "boolean" | "string" | "symbol" | "object" | "function";
3616    export interface NodeFactory {
3617        createNodeArray<T extends Node>(elements?: readonly T[], hasTrailingComma?: boolean): NodeArray<T>;
3618        createNumericLiteral(value: string | number, numericLiteralFlags?: TokenFlags): NumericLiteral;
3619        createBigIntLiteral(value: string | PseudoBigInt): BigIntLiteral;
3620        createStringLiteral(text: string, isSingleQuote?: boolean): StringLiteral;
3621        createStringLiteralFromNode(sourceNode: PropertyNameLiteral | PrivateIdentifier, isSingleQuote?: boolean): StringLiteral;
3622        createRegularExpressionLiteral(text: string): RegularExpressionLiteral;
3623        createIdentifier(text: string): Identifier;
3624        /**
3625         * Create a unique temporary variable.
3626         * @param recordTempVariable An optional callback used to record the temporary variable name. This
3627         * should usually be a reference to `hoistVariableDeclaration` from a `TransformationContext`, but
3628         * can be `undefined` if you plan to record the temporary variable manually.
3629         * @param reservedInNestedScopes When `true`, reserves the temporary variable name in all nested scopes
3630         * during emit so that the variable can be referenced in a nested function body. This is an alternative to
3631         * setting `EmitFlags.ReuseTempVariableScope` on the nested function itself.
3632         */
3633        createTempVariable(recordTempVariable: ((node: Identifier) => void) | undefined, reservedInNestedScopes?: boolean): Identifier;
3634        /**
3635         * Create a unique temporary variable for use in a loop.
3636         * @param reservedInNestedScopes When `true`, reserves the temporary variable name in all nested scopes
3637         * during emit so that the variable can be referenced in a nested function body. This is an alternative to
3638         * setting `EmitFlags.ReuseTempVariableScope` on the nested function itself.
3639         */
3640        createLoopVariable(reservedInNestedScopes?: boolean): Identifier;
3641        /** Create a unique name based on the supplied text. */
3642        createUniqueName(text: string, flags?: GeneratedIdentifierFlags): Identifier;
3643        /** Create a unique name generated for a node. */
3644        getGeneratedNameForNode(node: Node | undefined, flags?: GeneratedIdentifierFlags): Identifier;
3645        createPrivateIdentifier(text: string): PrivateIdentifier;
3646        createUniquePrivateName(text?: string): PrivateIdentifier;
3647        getGeneratedPrivateNameForNode(node: Node): PrivateIdentifier;
3648        createToken(token: SyntaxKind.SuperKeyword): SuperExpression;
3649        createToken(token: SyntaxKind.ThisKeyword): ThisExpression;
3650        createToken(token: SyntaxKind.NullKeyword): NullLiteral;
3651        createToken(token: SyntaxKind.TrueKeyword): TrueLiteral;
3652        createToken(token: SyntaxKind.FalseKeyword): FalseLiteral;
3653        createToken<TKind extends PunctuationSyntaxKind>(token: TKind): PunctuationToken<TKind>;
3654        createToken<TKind extends KeywordTypeSyntaxKind>(token: TKind): KeywordTypeNode<TKind>;
3655        createToken<TKind extends ModifierSyntaxKind>(token: TKind): ModifierToken<TKind>;
3656        createToken<TKind extends KeywordSyntaxKind>(token: TKind): KeywordToken<TKind>;
3657        createToken<TKind extends SyntaxKind.Unknown | SyntaxKind.EndOfFileToken>(token: TKind): Token<TKind>;
3658        createSuper(): SuperExpression;
3659        createThis(): ThisExpression;
3660        createNull(): NullLiteral;
3661        createTrue(): TrueLiteral;
3662        createFalse(): FalseLiteral;
3663        createModifier<T extends ModifierSyntaxKind>(kind: T): ModifierToken<T>;
3664        createModifiersFromModifierFlags(flags: ModifierFlags): Modifier[] | undefined;
3665        createQualifiedName(left: EntityName, right: string | Identifier): QualifiedName;
3666        updateQualifiedName(node: QualifiedName, left: EntityName, right: Identifier): QualifiedName;
3667        createComputedPropertyName(expression: Expression): ComputedPropertyName;
3668        updateComputedPropertyName(node: ComputedPropertyName, expression: Expression): ComputedPropertyName;
3669        createTypeParameterDeclaration(modifiers: readonly Modifier[] | undefined, name: string | Identifier, constraint?: TypeNode, defaultType?: TypeNode): TypeParameterDeclaration;
3670        updateTypeParameterDeclaration(node: TypeParameterDeclaration, modifiers: readonly Modifier[] | undefined, name: Identifier, constraint: TypeNode | undefined, defaultType: TypeNode | undefined): TypeParameterDeclaration;
3671        createParameterDeclaration(modifiers: readonly ModifierLike[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken?: QuestionToken, type?: TypeNode, initializer?: Expression): ParameterDeclaration;
3672        updateParameterDeclaration(node: ParameterDeclaration, modifiers: readonly ModifierLike[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): ParameterDeclaration;
3673        createDecorator(expression: Expression): Decorator;
3674        updateDecorator(node: Decorator, expression: Expression): Decorator;
3675        createPropertySignature(modifiers: readonly Modifier[] | undefined, name: PropertyName | string, questionToken: QuestionToken | undefined, type: TypeNode | undefined): PropertySignature;
3676        updatePropertySignature(node: PropertySignature, modifiers: readonly Modifier[] | undefined, name: PropertyName, questionToken: QuestionToken | undefined, type: TypeNode | undefined): PropertySignature;
3677        createPropertyDeclaration(modifiers: readonly ModifierLike[] | undefined, name: string | PropertyName, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertyDeclaration;
3678        updatePropertyDeclaration(node: PropertyDeclaration, modifiers: readonly ModifierLike[] | undefined, name: string | PropertyName, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertyDeclaration;
3679        createMethodSignature(modifiers: readonly Modifier[] | undefined, name: string | PropertyName, questionToken: QuestionToken | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined): MethodSignature;
3680        updateMethodSignature(node: MethodSignature, modifiers: readonly Modifier[] | undefined, name: PropertyName, questionToken: QuestionToken | undefined, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined): MethodSignature;
3681        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;
3682        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;
3683        createConstructorDeclaration(modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], body: Block | undefined): ConstructorDeclaration;
3684        updateConstructorDeclaration(node: ConstructorDeclaration, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], body: Block | undefined): ConstructorDeclaration;
3685        createGetAccessorDeclaration(modifiers: readonly ModifierLike[] | undefined, name: string | PropertyName, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): GetAccessorDeclaration;
3686        updateGetAccessorDeclaration(node: GetAccessorDeclaration, modifiers: readonly ModifierLike[] | undefined, name: PropertyName, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): GetAccessorDeclaration;
3687        createSetAccessorDeclaration(modifiers: readonly ModifierLike[] | undefined, name: string | PropertyName, parameters: readonly ParameterDeclaration[], body: Block | undefined): SetAccessorDeclaration;
3688        updateSetAccessorDeclaration(node: SetAccessorDeclaration, modifiers: readonly ModifierLike[] | undefined, name: PropertyName, parameters: readonly ParameterDeclaration[], body: Block | undefined): SetAccessorDeclaration;
3689        createCallSignature(typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined): CallSignatureDeclaration;
3690        updateCallSignature(node: CallSignatureDeclaration, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined): CallSignatureDeclaration;
3691        createConstructSignature(typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined): ConstructSignatureDeclaration;
3692        updateConstructSignature(node: ConstructSignatureDeclaration, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined): ConstructSignatureDeclaration;
3693        createIndexSignature(modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration;
3694        updateIndexSignature(node: IndexSignatureDeclaration, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration;
3695        createTemplateLiteralTypeSpan(type: TypeNode, literal: TemplateMiddle | TemplateTail): TemplateLiteralTypeSpan;
3696        updateTemplateLiteralTypeSpan(node: TemplateLiteralTypeSpan, type: TypeNode, literal: TemplateMiddle | TemplateTail): TemplateLiteralTypeSpan;
3697        createClassStaticBlockDeclaration(body: Block): ClassStaticBlockDeclaration;
3698        updateClassStaticBlockDeclaration(node: ClassStaticBlockDeclaration, body: Block): ClassStaticBlockDeclaration;
3699        createKeywordTypeNode<TKind extends KeywordTypeSyntaxKind>(kind: TKind): KeywordTypeNode<TKind>;
3700        createTypePredicateNode(assertsModifier: AssertsKeyword | undefined, parameterName: Identifier | ThisTypeNode | string, type: TypeNode | undefined): TypePredicateNode;
3701        updateTypePredicateNode(node: TypePredicateNode, assertsModifier: AssertsKeyword | undefined, parameterName: Identifier | ThisTypeNode, type: TypeNode | undefined): TypePredicateNode;
3702        createTypeReferenceNode(typeName: string | EntityName, typeArguments?: readonly TypeNode[]): TypeReferenceNode;
3703        updateTypeReferenceNode(node: TypeReferenceNode, typeName: EntityName, typeArguments: NodeArray<TypeNode> | undefined): TypeReferenceNode;
3704        createFunctionTypeNode(typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): FunctionTypeNode;
3705        updateFunctionTypeNode(node: FunctionTypeNode, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode): FunctionTypeNode;
3706        createConstructorTypeNode(modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): ConstructorTypeNode;
3707        updateConstructorTypeNode(node: ConstructorTypeNode, modifiers: readonly Modifier[] | undefined, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode): ConstructorTypeNode;
3708        createTypeQueryNode(exprName: EntityName, typeArguments?: readonly TypeNode[]): TypeQueryNode;
3709        updateTypeQueryNode(node: TypeQueryNode, exprName: EntityName, typeArguments?: readonly TypeNode[]): TypeQueryNode;
3710        createTypeLiteralNode(members: readonly TypeElement[] | undefined): TypeLiteralNode;
3711        updateTypeLiteralNode(node: TypeLiteralNode, members: NodeArray<TypeElement>): TypeLiteralNode;
3712        createArrayTypeNode(elementType: TypeNode): ArrayTypeNode;
3713        updateArrayTypeNode(node: ArrayTypeNode, elementType: TypeNode): ArrayTypeNode;
3714        createTupleTypeNode(elements: readonly (TypeNode | NamedTupleMember)[]): TupleTypeNode;
3715        updateTupleTypeNode(node: TupleTypeNode, elements: readonly (TypeNode | NamedTupleMember)[]): TupleTypeNode;
3716        createNamedTupleMember(dotDotDotToken: DotDotDotToken | undefined, name: Identifier, questionToken: QuestionToken | undefined, type: TypeNode): NamedTupleMember;
3717        updateNamedTupleMember(node: NamedTupleMember, dotDotDotToken: DotDotDotToken | undefined, name: Identifier, questionToken: QuestionToken | undefined, type: TypeNode): NamedTupleMember;
3718        createOptionalTypeNode(type: TypeNode): OptionalTypeNode;
3719        updateOptionalTypeNode(node: OptionalTypeNode, type: TypeNode): OptionalTypeNode;
3720        createRestTypeNode(type: TypeNode): RestTypeNode;
3721        updateRestTypeNode(node: RestTypeNode, type: TypeNode): RestTypeNode;
3722        createUnionTypeNode(types: readonly TypeNode[]): UnionTypeNode;
3723        updateUnionTypeNode(node: UnionTypeNode, types: NodeArray<TypeNode>): UnionTypeNode;
3724        createIntersectionTypeNode(types: readonly TypeNode[]): IntersectionTypeNode;
3725        updateIntersectionTypeNode(node: IntersectionTypeNode, types: NodeArray<TypeNode>): IntersectionTypeNode;
3726        createConditionalTypeNode(checkType: TypeNode, extendsType: TypeNode, trueType: TypeNode, falseType: TypeNode): ConditionalTypeNode;
3727        updateConditionalTypeNode(node: ConditionalTypeNode, checkType: TypeNode, extendsType: TypeNode, trueType: TypeNode, falseType: TypeNode): ConditionalTypeNode;
3728        createInferTypeNode(typeParameter: TypeParameterDeclaration): InferTypeNode;
3729        updateInferTypeNode(node: InferTypeNode, typeParameter: TypeParameterDeclaration): InferTypeNode;
3730        createImportTypeNode(argument: TypeNode, assertions?: ImportTypeAssertionContainer, qualifier?: EntityName, typeArguments?: readonly TypeNode[], isTypeOf?: boolean): ImportTypeNode;
3731        updateImportTypeNode(node: ImportTypeNode, argument: TypeNode, assertions: ImportTypeAssertionContainer | undefined, qualifier: EntityName | undefined, typeArguments: readonly TypeNode[] | undefined, isTypeOf?: boolean): ImportTypeNode;
3732        createParenthesizedType(type: TypeNode): ParenthesizedTypeNode;
3733        updateParenthesizedType(node: ParenthesizedTypeNode, type: TypeNode): ParenthesizedTypeNode;
3734        createThisTypeNode(): ThisTypeNode;
3735        createTypeOperatorNode(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword, type: TypeNode): TypeOperatorNode;
3736        updateTypeOperatorNode(node: TypeOperatorNode, type: TypeNode): TypeOperatorNode;
3737        createIndexedAccessTypeNode(objectType: TypeNode, indexType: TypeNode): IndexedAccessTypeNode;
3738        updateIndexedAccessTypeNode(node: IndexedAccessTypeNode, objectType: TypeNode, indexType: TypeNode): IndexedAccessTypeNode;
3739        createMappedTypeNode(readonlyToken: ReadonlyKeyword | PlusToken | MinusToken | undefined, typeParameter: TypeParameterDeclaration, nameType: TypeNode | undefined, questionToken: QuestionToken | PlusToken | MinusToken | undefined, type: TypeNode | undefined, members: NodeArray<TypeElement> | undefined): MappedTypeNode;
3740        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;
3741        createLiteralTypeNode(literal: LiteralTypeNode["literal"]): LiteralTypeNode;
3742        updateLiteralTypeNode(node: LiteralTypeNode, literal: LiteralTypeNode["literal"]): LiteralTypeNode;
3743        createTemplateLiteralType(head: TemplateHead, templateSpans: readonly TemplateLiteralTypeSpan[]): TemplateLiteralTypeNode;
3744        updateTemplateLiteralType(node: TemplateLiteralTypeNode, head: TemplateHead, templateSpans: readonly TemplateLiteralTypeSpan[]): TemplateLiteralTypeNode;
3745        createObjectBindingPattern(elements: readonly BindingElement[]): ObjectBindingPattern;
3746        updateObjectBindingPattern(node: ObjectBindingPattern, elements: readonly BindingElement[]): ObjectBindingPattern;
3747        createArrayBindingPattern(elements: readonly ArrayBindingElement[]): ArrayBindingPattern;
3748        updateArrayBindingPattern(node: ArrayBindingPattern, elements: readonly ArrayBindingElement[]): ArrayBindingPattern;
3749        createBindingElement(dotDotDotToken: DotDotDotToken | undefined, propertyName: string | PropertyName | undefined, name: string | BindingName, initializer?: Expression): BindingElement;
3750        updateBindingElement(node: BindingElement, dotDotDotToken: DotDotDotToken | undefined, propertyName: PropertyName | undefined, name: BindingName, initializer: Expression | undefined): BindingElement;
3751        createArrayLiteralExpression(elements?: readonly Expression[], multiLine?: boolean): ArrayLiteralExpression;
3752        updateArrayLiteralExpression(node: ArrayLiteralExpression, elements: readonly Expression[]): ArrayLiteralExpression;
3753        createObjectLiteralExpression(properties?: readonly ObjectLiteralElementLike[], multiLine?: boolean): ObjectLiteralExpression;
3754        updateObjectLiteralExpression(node: ObjectLiteralExpression, properties: readonly ObjectLiteralElementLike[]): ObjectLiteralExpression;
3755        createPropertyAccessExpression(expression: Expression, name: string | MemberName): PropertyAccessExpression;
3756        updatePropertyAccessExpression(node: PropertyAccessExpression, expression: Expression, name: MemberName): PropertyAccessExpression;
3757        createPropertyAccessChain(expression: Expression, questionDotToken: QuestionDotToken | undefined, name: string | MemberName): PropertyAccessChain;
3758        updatePropertyAccessChain(node: PropertyAccessChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, name: MemberName): PropertyAccessChain;
3759        createElementAccessExpression(expression: Expression, index: number | Expression): ElementAccessExpression;
3760        updateElementAccessExpression(node: ElementAccessExpression, expression: Expression, argumentExpression: Expression): ElementAccessExpression;
3761        createElementAccessChain(expression: Expression, questionDotToken: QuestionDotToken | undefined, index: number | Expression): ElementAccessChain;
3762        updateElementAccessChain(node: ElementAccessChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, argumentExpression: Expression): ElementAccessChain;
3763        createCallExpression(expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): CallExpression;
3764        updateCallExpression(node: CallExpression, expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[]): CallExpression;
3765        createCallChain(expression: Expression, questionDotToken: QuestionDotToken | undefined, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): CallChain;
3766        updateCallChain(node: CallChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[]): CallChain;
3767        createNewExpression(expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): NewExpression;
3768        updateNewExpression(node: NewExpression, expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined): NewExpression;
3769        createTaggedTemplateExpression(tag: Expression, typeArguments: readonly TypeNode[] | undefined, template: TemplateLiteral): TaggedTemplateExpression;
3770        updateTaggedTemplateExpression(node: TaggedTemplateExpression, tag: Expression, typeArguments: readonly TypeNode[] | undefined, template: TemplateLiteral): TaggedTemplateExpression;
3771        createTypeAssertion(type: TypeNode, expression: Expression): TypeAssertion;
3772        updateTypeAssertion(node: TypeAssertion, type: TypeNode, expression: Expression): TypeAssertion;
3773        createParenthesizedExpression(expression: Expression): ParenthesizedExpression;
3774        updateParenthesizedExpression(node: ParenthesizedExpression, expression: Expression): ParenthesizedExpression;
3775        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;
3776        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;
3777        createArrowFunction(modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, equalsGreaterThanToken: EqualsGreaterThanToken | undefined, body: ConciseBody): ArrowFunction;
3778        updateArrowFunction(node: ArrowFunction, modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, equalsGreaterThanToken: EqualsGreaterThanToken, body: ConciseBody): ArrowFunction;
3779        createEtsComponentExpression(name: Expression, argumentExpression: Expression[] | NodeArray<Expression> | undefined, body: Block | undefined): EtsComponentExpression;
3780        updateEtsComponentExpression(node: EtsComponentExpression, name: Expression | undefined, argumentExpression: Expression[] | NodeArray<Expression> | undefined, body: Block | undefined): EtsComponentExpression;
3781        createDeleteExpression(expression: Expression): DeleteExpression;
3782        updateDeleteExpression(node: DeleteExpression, expression: Expression): DeleteExpression;
3783        createTypeOfExpression(expression: Expression): TypeOfExpression;
3784        updateTypeOfExpression(node: TypeOfExpression, expression: Expression): TypeOfExpression;
3785        createVoidExpression(expression: Expression): VoidExpression;
3786        updateVoidExpression(node: VoidExpression, expression: Expression): VoidExpression;
3787        createAwaitExpression(expression: Expression): AwaitExpression;
3788        updateAwaitExpression(node: AwaitExpression, expression: Expression): AwaitExpression;
3789        createPrefixUnaryExpression(operator: PrefixUnaryOperator, operand: Expression): PrefixUnaryExpression;
3790        updatePrefixUnaryExpression(node: PrefixUnaryExpression, operand: Expression): PrefixUnaryExpression;
3791        createPostfixUnaryExpression(operand: Expression, operator: PostfixUnaryOperator): PostfixUnaryExpression;
3792        updatePostfixUnaryExpression(node: PostfixUnaryExpression, operand: Expression): PostfixUnaryExpression;
3793        createBinaryExpression(left: Expression, operator: BinaryOperator | BinaryOperatorToken, right: Expression): BinaryExpression;
3794        updateBinaryExpression(node: BinaryExpression, left: Expression, operator: BinaryOperator | BinaryOperatorToken, right: Expression): BinaryExpression;
3795        createConditionalExpression(condition: Expression, questionToken: QuestionToken | undefined, whenTrue: Expression, colonToken: ColonToken | undefined, whenFalse: Expression): ConditionalExpression;
3796        updateConditionalExpression(node: ConditionalExpression, condition: Expression, questionToken: QuestionToken, whenTrue: Expression, colonToken: ColonToken, whenFalse: Expression): ConditionalExpression;
3797        createTemplateExpression(head: TemplateHead, templateSpans: readonly TemplateSpan[]): TemplateExpression;
3798        updateTemplateExpression(node: TemplateExpression, head: TemplateHead, templateSpans: readonly TemplateSpan[]): TemplateExpression;
3799        createTemplateHead(text: string, rawText?: string, templateFlags?: TokenFlags): TemplateHead;
3800        createTemplateHead(text: string | undefined, rawText: string, templateFlags?: TokenFlags): TemplateHead;
3801        createTemplateMiddle(text: string, rawText?: string, templateFlags?: TokenFlags): TemplateMiddle;
3802        createTemplateMiddle(text: string | undefined, rawText: string, templateFlags?: TokenFlags): TemplateMiddle;
3803        createTemplateTail(text: string, rawText?: string, templateFlags?: TokenFlags): TemplateTail;
3804        createTemplateTail(text: string | undefined, rawText: string, templateFlags?: TokenFlags): TemplateTail;
3805        createNoSubstitutionTemplateLiteral(text: string, rawText?: string): NoSubstitutionTemplateLiteral;
3806        createNoSubstitutionTemplateLiteral(text: string | undefined, rawText: string): NoSubstitutionTemplateLiteral;
3807        createYieldExpression(asteriskToken: AsteriskToken, expression: Expression): YieldExpression;
3808        createYieldExpression(asteriskToken: undefined, expression: Expression | undefined): YieldExpression;
3809        updateYieldExpression(node: YieldExpression, asteriskToken: AsteriskToken | undefined, expression: Expression | undefined): YieldExpression;
3810        createSpreadElement(expression: Expression): SpreadElement;
3811        updateSpreadElement(node: SpreadElement, expression: Expression): SpreadElement;
3812        createClassExpression(modifiers: readonly ModifierLike[] | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassExpression;
3813        updateClassExpression(node: ClassExpression, modifiers: readonly ModifierLike[] | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassExpression;
3814        createOmittedExpression(): OmittedExpression;
3815        createExpressionWithTypeArguments(expression: Expression, typeArguments: readonly TypeNode[] | undefined): ExpressionWithTypeArguments;
3816        updateExpressionWithTypeArguments(node: ExpressionWithTypeArguments, expression: Expression, typeArguments: readonly TypeNode[] | undefined): ExpressionWithTypeArguments;
3817        createAsExpression(expression: Expression, type: TypeNode): AsExpression;
3818        updateAsExpression(node: AsExpression, expression: Expression, type: TypeNode): AsExpression;
3819        createNonNullExpression(expression: Expression): NonNullExpression;
3820        updateNonNullExpression(node: NonNullExpression, expression: Expression): NonNullExpression;
3821        createNonNullChain(expression: Expression): NonNullChain;
3822        updateNonNullChain(node: NonNullChain, expression: Expression): NonNullChain;
3823        createMetaProperty(keywordToken: MetaProperty["keywordToken"], name: Identifier): MetaProperty;
3824        updateMetaProperty(node: MetaProperty, name: Identifier): MetaProperty;
3825        createSatisfiesExpression(expression: Expression, type: TypeNode): SatisfiesExpression;
3826        updateSatisfiesExpression(node: SatisfiesExpression, expression: Expression, type: TypeNode): SatisfiesExpression;
3827        createTemplateSpan(expression: Expression, literal: TemplateMiddle | TemplateTail): TemplateSpan;
3828        updateTemplateSpan(node: TemplateSpan, expression: Expression, literal: TemplateMiddle | TemplateTail): TemplateSpan;
3829        createSemicolonClassElement(): SemicolonClassElement;
3830        createBlock(statements: readonly Statement[], multiLine?: boolean): Block;
3831        updateBlock(node: Block, statements: readonly Statement[]): Block;
3832        createVariableStatement(modifiers: readonly Modifier[] | undefined, declarationList: VariableDeclarationList | readonly VariableDeclaration[]): VariableStatement;
3833        updateVariableStatement(node: VariableStatement, modifiers: readonly Modifier[] | undefined, declarationList: VariableDeclarationList): VariableStatement;
3834        createEmptyStatement(): EmptyStatement;
3835        createExpressionStatement(expression: Expression): ExpressionStatement;
3836        updateExpressionStatement(node: ExpressionStatement, expression: Expression): ExpressionStatement;
3837        createIfStatement(expression: Expression, thenStatement: Statement, elseStatement?: Statement): IfStatement;
3838        updateIfStatement(node: IfStatement, expression: Expression, thenStatement: Statement, elseStatement: Statement | undefined): IfStatement;
3839        createDoStatement(statement: Statement, expression: Expression): DoStatement;
3840        updateDoStatement(node: DoStatement, statement: Statement, expression: Expression): DoStatement;
3841        createWhileStatement(expression: Expression, statement: Statement): WhileStatement;
3842        updateWhileStatement(node: WhileStatement, expression: Expression, statement: Statement): WhileStatement;
3843        createForStatement(initializer: ForInitializer | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement): ForStatement;
3844        updateForStatement(node: ForStatement, initializer: ForInitializer | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement): ForStatement;
3845        createForInStatement(initializer: ForInitializer, expression: Expression, statement: Statement): ForInStatement;
3846        updateForInStatement(node: ForInStatement, initializer: ForInitializer, expression: Expression, statement: Statement): ForInStatement;
3847        createForOfStatement(awaitModifier: AwaitKeyword | undefined, initializer: ForInitializer, expression: Expression, statement: Statement): ForOfStatement;
3848        updateForOfStatement(node: ForOfStatement, awaitModifier: AwaitKeyword | undefined, initializer: ForInitializer, expression: Expression, statement: Statement): ForOfStatement;
3849        createContinueStatement(label?: string | Identifier): ContinueStatement;
3850        updateContinueStatement(node: ContinueStatement, label: Identifier | undefined): ContinueStatement;
3851        createBreakStatement(label?: string | Identifier): BreakStatement;
3852        updateBreakStatement(node: BreakStatement, label: Identifier | undefined): BreakStatement;
3853        createReturnStatement(expression?: Expression): ReturnStatement;
3854        updateReturnStatement(node: ReturnStatement, expression: Expression | undefined): ReturnStatement;
3855        createWithStatement(expression: Expression, statement: Statement): WithStatement;
3856        updateWithStatement(node: WithStatement, expression: Expression, statement: Statement): WithStatement;
3857        createSwitchStatement(expression: Expression, caseBlock: CaseBlock): SwitchStatement;
3858        updateSwitchStatement(node: SwitchStatement, expression: Expression, caseBlock: CaseBlock): SwitchStatement;
3859        createLabeledStatement(label: string | Identifier, statement: Statement): LabeledStatement;
3860        updateLabeledStatement(node: LabeledStatement, label: Identifier, statement: Statement): LabeledStatement;
3861        createThrowStatement(expression: Expression): ThrowStatement;
3862        updateThrowStatement(node: ThrowStatement, expression: Expression): ThrowStatement;
3863        createTryStatement(tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined): TryStatement;
3864        updateTryStatement(node: TryStatement, tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined): TryStatement;
3865        createDebuggerStatement(): DebuggerStatement;
3866        createVariableDeclaration(name: string | BindingName, exclamationToken?: ExclamationToken, type?: TypeNode, initializer?: Expression): VariableDeclaration;
3867        updateVariableDeclaration(node: VariableDeclaration, name: BindingName, exclamationToken: ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): VariableDeclaration;
3868        createVariableDeclarationList(declarations: readonly VariableDeclaration[], flags?: NodeFlags): VariableDeclarationList;
3869        updateVariableDeclarationList(node: VariableDeclarationList, declarations: readonly VariableDeclaration[]): VariableDeclarationList;
3870        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;
3871        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;
3872        createClassDeclaration(modifiers: readonly ModifierLike[] | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassDeclaration;
3873        updateClassDeclaration(node: ClassDeclaration, modifiers: readonly ModifierLike[] | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassDeclaration;
3874        createStructDeclaration(modifiers: readonly ModifierLike[] | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): StructDeclaration;
3875        updateStructDeclaration(node: StructDeclaration, modifiers: readonly ModifierLike[] | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): StructDeclaration;
3876        createInterfaceDeclaration(modifiers: readonly Modifier[] | undefined, name: string | Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly TypeElement[]): InterfaceDeclaration;
3877        updateInterfaceDeclaration(node: InterfaceDeclaration, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly TypeElement[]): InterfaceDeclaration;
3878        createTypeAliasDeclaration(modifiers: readonly Modifier[] | undefined, name: string | Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration;
3879        updateTypeAliasDeclaration(node: TypeAliasDeclaration, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration;
3880        createEnumDeclaration(modifiers: readonly Modifier[] | undefined, name: string | Identifier, members: readonly EnumMember[]): EnumDeclaration;
3881        updateEnumDeclaration(node: EnumDeclaration, modifiers: readonly Modifier[] | undefined, name: Identifier, members: readonly EnumMember[]): EnumDeclaration;
3882        createModuleDeclaration(modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined, flags?: NodeFlags): ModuleDeclaration;
3883        updateModuleDeclaration(node: ModuleDeclaration, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined): ModuleDeclaration;
3884        createModuleBlock(statements: readonly Statement[]): ModuleBlock;
3885        updateModuleBlock(node: ModuleBlock, statements: readonly Statement[]): ModuleBlock;
3886        createCaseBlock(clauses: readonly CaseOrDefaultClause[]): CaseBlock;
3887        updateCaseBlock(node: CaseBlock, clauses: readonly CaseOrDefaultClause[]): CaseBlock;
3888        createNamespaceExportDeclaration(name: string | Identifier): NamespaceExportDeclaration;
3889        updateNamespaceExportDeclaration(node: NamespaceExportDeclaration, name: Identifier): NamespaceExportDeclaration;
3890        createImportEqualsDeclaration(modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: string | Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration;
3891        updateImportEqualsDeclaration(node: ImportEqualsDeclaration, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration;
3892        createImportDeclaration(modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause?: AssertClause): ImportDeclaration;
3893        updateImportDeclaration(node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration;
3894        createImportClause(isTypeOnly: boolean, name: Identifier | undefined, namedBindings: NamedImportBindings | undefined): ImportClause;
3895        updateImportClause(node: ImportClause, isTypeOnly: boolean, name: Identifier | undefined, namedBindings: NamedImportBindings | undefined): ImportClause;
3896        createAssertClause(elements: NodeArray<AssertEntry>, multiLine?: boolean): AssertClause;
3897        updateAssertClause(node: AssertClause, elements: NodeArray<AssertEntry>, multiLine?: boolean): AssertClause;
3898        createAssertEntry(name: AssertionKey, value: Expression): AssertEntry;
3899        updateAssertEntry(node: AssertEntry, name: AssertionKey, value: Expression): AssertEntry;
3900        createImportTypeAssertionContainer(clause: AssertClause, multiLine?: boolean): ImportTypeAssertionContainer;
3901        updateImportTypeAssertionContainer(node: ImportTypeAssertionContainer, clause: AssertClause, multiLine?: boolean): ImportTypeAssertionContainer;
3902        createNamespaceImport(name: Identifier): NamespaceImport;
3903        updateNamespaceImport(node: NamespaceImport, name: Identifier): NamespaceImport;
3904        createNamespaceExport(name: Identifier): NamespaceExport;
3905        updateNamespaceExport(node: NamespaceExport, name: Identifier): NamespaceExport;
3906        createNamedImports(elements: readonly ImportSpecifier[]): NamedImports;
3907        updateNamedImports(node: NamedImports, elements: readonly ImportSpecifier[]): NamedImports;
3908        createImportSpecifier(isTypeOnly: boolean, propertyName: Identifier | undefined, name: Identifier): ImportSpecifier;
3909        updateImportSpecifier(node: ImportSpecifier, isTypeOnly: boolean, propertyName: Identifier | undefined, name: Identifier): ImportSpecifier;
3910        createExportAssignment(modifiers: readonly Modifier[] | undefined, isExportEquals: boolean | undefined, expression: Expression): ExportAssignment;
3911        updateExportAssignment(node: ExportAssignment, modifiers: readonly Modifier[] | undefined, expression: Expression): ExportAssignment;
3912        createExportDeclaration(modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, exportClause: NamedExportBindings | undefined, moduleSpecifier?: Expression, assertClause?: AssertClause): ExportDeclaration;
3913        updateExportDeclaration(node: ExportDeclaration, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, exportClause: NamedExportBindings | undefined, moduleSpecifier: Expression | undefined, assertClause: AssertClause | undefined): ExportDeclaration;
3914        createNamedExports(elements: readonly ExportSpecifier[]): NamedExports;
3915        updateNamedExports(node: NamedExports, elements: readonly ExportSpecifier[]): NamedExports;
3916        createExportSpecifier(isTypeOnly: boolean, propertyName: string | Identifier | undefined, name: string | Identifier): ExportSpecifier;
3917        updateExportSpecifier(node: ExportSpecifier, isTypeOnly: boolean, propertyName: Identifier | undefined, name: Identifier): ExportSpecifier;
3918        createExternalModuleReference(expression: Expression): ExternalModuleReference;
3919        updateExternalModuleReference(node: ExternalModuleReference, expression: Expression): ExternalModuleReference;
3920        createJSDocAllType(): JSDocAllType;
3921        createJSDocUnknownType(): JSDocUnknownType;
3922        createJSDocNonNullableType(type: TypeNode, postfix?: boolean): JSDocNonNullableType;
3923        updateJSDocNonNullableType(node: JSDocNonNullableType, type: TypeNode): JSDocNonNullableType;
3924        createJSDocNullableType(type: TypeNode, postfix?: boolean): JSDocNullableType;
3925        updateJSDocNullableType(node: JSDocNullableType, type: TypeNode): JSDocNullableType;
3926        createJSDocOptionalType(type: TypeNode): JSDocOptionalType;
3927        updateJSDocOptionalType(node: JSDocOptionalType, type: TypeNode): JSDocOptionalType;
3928        createJSDocFunctionType(parameters: readonly ParameterDeclaration[], type: TypeNode | undefined): JSDocFunctionType;
3929        updateJSDocFunctionType(node: JSDocFunctionType, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined): JSDocFunctionType;
3930        createJSDocVariadicType(type: TypeNode): JSDocVariadicType;
3931        updateJSDocVariadicType(node: JSDocVariadicType, type: TypeNode): JSDocVariadicType;
3932        createJSDocNamepathType(type: TypeNode): JSDocNamepathType;
3933        updateJSDocNamepathType(node: JSDocNamepathType, type: TypeNode): JSDocNamepathType;
3934        createJSDocTypeExpression(type: TypeNode): JSDocTypeExpression;
3935        updateJSDocTypeExpression(node: JSDocTypeExpression, type: TypeNode): JSDocTypeExpression;
3936        createJSDocNameReference(name: EntityName | JSDocMemberName): JSDocNameReference;
3937        updateJSDocNameReference(node: JSDocNameReference, name: EntityName | JSDocMemberName): JSDocNameReference;
3938        createJSDocMemberName(left: EntityName | JSDocMemberName, right: Identifier): JSDocMemberName;
3939        updateJSDocMemberName(node: JSDocMemberName, left: EntityName | JSDocMemberName, right: Identifier): JSDocMemberName;
3940        createJSDocLink(name: EntityName | JSDocMemberName | undefined, text: string): JSDocLink;
3941        updateJSDocLink(node: JSDocLink, name: EntityName | JSDocMemberName | undefined, text: string): JSDocLink;
3942        createJSDocLinkCode(name: EntityName | JSDocMemberName | undefined, text: string): JSDocLinkCode;
3943        updateJSDocLinkCode(node: JSDocLinkCode, name: EntityName | JSDocMemberName | undefined, text: string): JSDocLinkCode;
3944        createJSDocLinkPlain(name: EntityName | JSDocMemberName | undefined, text: string): JSDocLinkPlain;
3945        updateJSDocLinkPlain(node: JSDocLinkPlain, name: EntityName | JSDocMemberName | undefined, text: string): JSDocLinkPlain;
3946        createJSDocTypeLiteral(jsDocPropertyTags?: readonly JSDocPropertyLikeTag[], isArrayType?: boolean): JSDocTypeLiteral;
3947        updateJSDocTypeLiteral(node: JSDocTypeLiteral, jsDocPropertyTags: readonly JSDocPropertyLikeTag[] | undefined, isArrayType: boolean | undefined): JSDocTypeLiteral;
3948        createJSDocSignature(typeParameters: readonly JSDocTemplateTag[] | undefined, parameters: readonly JSDocParameterTag[], type?: JSDocReturnTag): JSDocSignature;
3949        updateJSDocSignature(node: JSDocSignature, typeParameters: readonly JSDocTemplateTag[] | undefined, parameters: readonly JSDocParameterTag[], type: JSDocReturnTag | undefined): JSDocSignature;
3950        createJSDocTemplateTag(tagName: Identifier | undefined, constraint: JSDocTypeExpression | undefined, typeParameters: readonly TypeParameterDeclaration[], comment?: string | NodeArray<JSDocComment>): JSDocTemplateTag;
3951        updateJSDocTemplateTag(node: JSDocTemplateTag, tagName: Identifier | undefined, constraint: JSDocTypeExpression | undefined, typeParameters: readonly TypeParameterDeclaration[], comment: string | NodeArray<JSDocComment> | undefined): JSDocTemplateTag;
3952        createJSDocTypedefTag(tagName: Identifier | undefined, typeExpression?: JSDocTypeExpression | JSDocTypeLiteral, fullName?: Identifier | JSDocNamespaceDeclaration, comment?: string | NodeArray<JSDocComment>): JSDocTypedefTag;
3953        updateJSDocTypedefTag(node: JSDocTypedefTag, tagName: Identifier | undefined, typeExpression: JSDocTypeExpression | JSDocTypeLiteral | undefined, fullName: Identifier | JSDocNamespaceDeclaration | undefined, comment: string | NodeArray<JSDocComment> | undefined): JSDocTypedefTag;
3954        createJSDocParameterTag(tagName: Identifier | undefined, name: EntityName, isBracketed: boolean, typeExpression?: JSDocTypeExpression, isNameFirst?: boolean, comment?: string | NodeArray<JSDocComment>): JSDocParameterTag;
3955        updateJSDocParameterTag(node: JSDocParameterTag, tagName: Identifier | undefined, name: EntityName, isBracketed: boolean, typeExpression: JSDocTypeExpression | undefined, isNameFirst: boolean, comment: string | NodeArray<JSDocComment> | undefined): JSDocParameterTag;
3956        createJSDocPropertyTag(tagName: Identifier | undefined, name: EntityName, isBracketed: boolean, typeExpression?: JSDocTypeExpression, isNameFirst?: boolean, comment?: string | NodeArray<JSDocComment>): JSDocPropertyTag;
3957        updateJSDocPropertyTag(node: JSDocPropertyTag, tagName: Identifier | undefined, name: EntityName, isBracketed: boolean, typeExpression: JSDocTypeExpression | undefined, isNameFirst: boolean, comment: string | NodeArray<JSDocComment> | undefined): JSDocPropertyTag;
3958        createJSDocTypeTag(tagName: Identifier | undefined, typeExpression: JSDocTypeExpression, comment?: string | NodeArray<JSDocComment>): JSDocTypeTag;
3959        updateJSDocTypeTag(node: JSDocTypeTag, tagName: Identifier | undefined, typeExpression: JSDocTypeExpression, comment: string | NodeArray<JSDocComment> | undefined): JSDocTypeTag;
3960        createJSDocSeeTag(tagName: Identifier | undefined, nameExpression: JSDocNameReference | undefined, comment?: string | NodeArray<JSDocComment>): JSDocSeeTag;
3961        updateJSDocSeeTag(node: JSDocSeeTag, tagName: Identifier | undefined, nameExpression: JSDocNameReference | undefined, comment?: string | NodeArray<JSDocComment>): JSDocSeeTag;
3962        createJSDocReturnTag(tagName: Identifier | undefined, typeExpression?: JSDocTypeExpression, comment?: string | NodeArray<JSDocComment>): JSDocReturnTag;
3963        updateJSDocReturnTag(node: JSDocReturnTag, tagName: Identifier | undefined, typeExpression: JSDocTypeExpression | undefined, comment: string | NodeArray<JSDocComment> | undefined): JSDocReturnTag;
3964        createJSDocThisTag(tagName: Identifier | undefined, typeExpression: JSDocTypeExpression, comment?: string | NodeArray<JSDocComment>): JSDocThisTag;
3965        updateJSDocThisTag(node: JSDocThisTag, tagName: Identifier | undefined, typeExpression: JSDocTypeExpression | undefined, comment: string | NodeArray<JSDocComment> | undefined): JSDocThisTag;
3966        createJSDocEnumTag(tagName: Identifier | undefined, typeExpression: JSDocTypeExpression, comment?: string | NodeArray<JSDocComment>): JSDocEnumTag;
3967        updateJSDocEnumTag(node: JSDocEnumTag, tagName: Identifier | undefined, typeExpression: JSDocTypeExpression, comment: string | NodeArray<JSDocComment> | undefined): JSDocEnumTag;
3968        createJSDocCallbackTag(tagName: Identifier | undefined, typeExpression: JSDocSignature, fullName?: Identifier | JSDocNamespaceDeclaration, comment?: string | NodeArray<JSDocComment>): JSDocCallbackTag;
3969        updateJSDocCallbackTag(node: JSDocCallbackTag, tagName: Identifier | undefined, typeExpression: JSDocSignature, fullName: Identifier | JSDocNamespaceDeclaration | undefined, comment: string | NodeArray<JSDocComment> | undefined): JSDocCallbackTag;
3970        createJSDocAugmentsTag(tagName: Identifier | undefined, className: JSDocAugmentsTag["class"], comment?: string | NodeArray<JSDocComment>): JSDocAugmentsTag;
3971        updateJSDocAugmentsTag(node: JSDocAugmentsTag, tagName: Identifier | undefined, className: JSDocAugmentsTag["class"], comment: string | NodeArray<JSDocComment> | undefined): JSDocAugmentsTag;
3972        createJSDocImplementsTag(tagName: Identifier | undefined, className: JSDocImplementsTag["class"], comment?: string | NodeArray<JSDocComment>): JSDocImplementsTag;
3973        updateJSDocImplementsTag(node: JSDocImplementsTag, tagName: Identifier | undefined, className: JSDocImplementsTag["class"], comment: string | NodeArray<JSDocComment> | undefined): JSDocImplementsTag;
3974        createJSDocAuthorTag(tagName: Identifier | undefined, comment?: string | NodeArray<JSDocComment>): JSDocAuthorTag;
3975        updateJSDocAuthorTag(node: JSDocAuthorTag, tagName: Identifier | undefined, comment: string | NodeArray<JSDocComment> | undefined): JSDocAuthorTag;
3976        createJSDocClassTag(tagName: Identifier | undefined, comment?: string | NodeArray<JSDocComment>): JSDocClassTag;
3977        updateJSDocClassTag(node: JSDocClassTag, tagName: Identifier | undefined, comment: string | NodeArray<JSDocComment> | undefined): JSDocClassTag;
3978        createJSDocPublicTag(tagName: Identifier | undefined, comment?: string | NodeArray<JSDocComment>): JSDocPublicTag;
3979        updateJSDocPublicTag(node: JSDocPublicTag, tagName: Identifier | undefined, comment: string | NodeArray<JSDocComment> | undefined): JSDocPublicTag;
3980        createJSDocPrivateTag(tagName: Identifier | undefined, comment?: string | NodeArray<JSDocComment>): JSDocPrivateTag;
3981        updateJSDocPrivateTag(node: JSDocPrivateTag, tagName: Identifier | undefined, comment: string | NodeArray<JSDocComment> | undefined): JSDocPrivateTag;
3982        createJSDocProtectedTag(tagName: Identifier | undefined, comment?: string | NodeArray<JSDocComment>): JSDocProtectedTag;
3983        updateJSDocProtectedTag(node: JSDocProtectedTag, tagName: Identifier | undefined, comment: string | NodeArray<JSDocComment> | undefined): JSDocProtectedTag;
3984        createJSDocReadonlyTag(tagName: Identifier | undefined, comment?: string | NodeArray<JSDocComment>): JSDocReadonlyTag;
3985        updateJSDocReadonlyTag(node: JSDocReadonlyTag, tagName: Identifier | undefined, comment: string | NodeArray<JSDocComment> | undefined): JSDocReadonlyTag;
3986        createJSDocUnknownTag(tagName: Identifier, comment?: string | NodeArray<JSDocComment>): JSDocUnknownTag;
3987        updateJSDocUnknownTag(node: JSDocUnknownTag, tagName: Identifier, comment: string | NodeArray<JSDocComment> | undefined): JSDocUnknownTag;
3988        createJSDocDeprecatedTag(tagName: Identifier, comment?: string | NodeArray<JSDocComment>): JSDocDeprecatedTag;
3989        updateJSDocDeprecatedTag(node: JSDocDeprecatedTag, tagName: Identifier, comment?: string | NodeArray<JSDocComment>): JSDocDeprecatedTag;
3990        createJSDocOverrideTag(tagName: Identifier, comment?: string | NodeArray<JSDocComment>): JSDocOverrideTag;
3991        updateJSDocOverrideTag(node: JSDocOverrideTag, tagName: Identifier, comment?: string | NodeArray<JSDocComment>): JSDocOverrideTag;
3992        createJSDocText(text: string): JSDocText;
3993        updateJSDocText(node: JSDocText, text: string): JSDocText;
3994        createJSDocComment(comment?: string | NodeArray<JSDocComment> | undefined, tags?: readonly JSDocTag[] | undefined): JSDoc;
3995        updateJSDocComment(node: JSDoc, comment: string | NodeArray<JSDocComment> | undefined, tags: readonly JSDocTag[] | undefined): JSDoc;
3996        createJsxElement(openingElement: JsxOpeningElement, children: readonly JsxChild[], closingElement: JsxClosingElement): JsxElement;
3997        updateJsxElement(node: JsxElement, openingElement: JsxOpeningElement, children: readonly JsxChild[], closingElement: JsxClosingElement): JsxElement;
3998        createJsxSelfClosingElement(tagName: JsxTagNameExpression, typeArguments: readonly TypeNode[] | undefined, attributes: JsxAttributes): JsxSelfClosingElement;
3999        updateJsxSelfClosingElement(node: JsxSelfClosingElement, tagName: JsxTagNameExpression, typeArguments: readonly TypeNode[] | undefined, attributes: JsxAttributes): JsxSelfClosingElement;
4000        createJsxOpeningElement(tagName: JsxTagNameExpression, typeArguments: readonly TypeNode[] | undefined, attributes: JsxAttributes): JsxOpeningElement;
4001        updateJsxOpeningElement(node: JsxOpeningElement, tagName: JsxTagNameExpression, typeArguments: readonly TypeNode[] | undefined, attributes: JsxAttributes): JsxOpeningElement;
4002        createJsxClosingElement(tagName: JsxTagNameExpression): JsxClosingElement;
4003        updateJsxClosingElement(node: JsxClosingElement, tagName: JsxTagNameExpression): JsxClosingElement;
4004        createJsxFragment(openingFragment: JsxOpeningFragment, children: readonly JsxChild[], closingFragment: JsxClosingFragment): JsxFragment;
4005        createJsxText(text: string, containsOnlyTriviaWhiteSpaces?: boolean): JsxText;
4006        updateJsxText(node: JsxText, text: string, containsOnlyTriviaWhiteSpaces?: boolean): JsxText;
4007        createJsxOpeningFragment(): JsxOpeningFragment;
4008        createJsxJsxClosingFragment(): JsxClosingFragment;
4009        updateJsxFragment(node: JsxFragment, openingFragment: JsxOpeningFragment, children: readonly JsxChild[], closingFragment: JsxClosingFragment): JsxFragment;
4010        createJsxAttribute(name: Identifier, initializer: JsxAttributeValue | undefined): JsxAttribute;
4011        updateJsxAttribute(node: JsxAttribute, name: Identifier, initializer: JsxAttributeValue | undefined): JsxAttribute;
4012        createJsxAttributes(properties: readonly JsxAttributeLike[]): JsxAttributes;
4013        updateJsxAttributes(node: JsxAttributes, properties: readonly JsxAttributeLike[]): JsxAttributes;
4014        createJsxSpreadAttribute(expression: Expression): JsxSpreadAttribute;
4015        updateJsxSpreadAttribute(node: JsxSpreadAttribute, expression: Expression): JsxSpreadAttribute;
4016        createJsxExpression(dotDotDotToken: DotDotDotToken | undefined, expression: Expression | undefined): JsxExpression;
4017        updateJsxExpression(node: JsxExpression, expression: Expression | undefined): JsxExpression;
4018        createCaseClause(expression: Expression, statements: readonly Statement[]): CaseClause;
4019        updateCaseClause(node: CaseClause, expression: Expression, statements: readonly Statement[]): CaseClause;
4020        createDefaultClause(statements: readonly Statement[]): DefaultClause;
4021        updateDefaultClause(node: DefaultClause, statements: readonly Statement[]): DefaultClause;
4022        createHeritageClause(token: HeritageClause["token"], types: readonly ExpressionWithTypeArguments[]): HeritageClause;
4023        updateHeritageClause(node: HeritageClause, types: readonly ExpressionWithTypeArguments[]): HeritageClause;
4024        createCatchClause(variableDeclaration: string | BindingName | VariableDeclaration | undefined, block: Block): CatchClause;
4025        updateCatchClause(node: CatchClause, variableDeclaration: VariableDeclaration | undefined, block: Block): CatchClause;
4026        createPropertyAssignment(name: string | PropertyName, initializer: Expression): PropertyAssignment;
4027        updatePropertyAssignment(node: PropertyAssignment, name: PropertyName, initializer: Expression): PropertyAssignment;
4028        createShorthandPropertyAssignment(name: string | Identifier, objectAssignmentInitializer?: Expression): ShorthandPropertyAssignment;
4029        updateShorthandPropertyAssignment(node: ShorthandPropertyAssignment, name: Identifier, objectAssignmentInitializer: Expression | undefined): ShorthandPropertyAssignment;
4030        createSpreadAssignment(expression: Expression): SpreadAssignment;
4031        updateSpreadAssignment(node: SpreadAssignment, expression: Expression): SpreadAssignment;
4032        createEnumMember(name: string | PropertyName, initializer?: Expression): EnumMember;
4033        updateEnumMember(node: EnumMember, name: PropertyName, initializer: Expression | undefined): EnumMember;
4034        createSourceFile(statements: readonly Statement[], endOfFileToken: EndOfFileToken, flags: NodeFlags): SourceFile;
4035        updateSourceFile(node: SourceFile, statements: readonly Statement[], isDeclarationFile?: boolean, referencedFiles?: readonly FileReference[], typeReferences?: readonly FileReference[], hasNoDefaultLib?: boolean, libReferences?: readonly FileReference[]): SourceFile;
4036        createNotEmittedStatement(original: Node): NotEmittedStatement;
4037        createPartiallyEmittedExpression(expression: Expression, original?: Node): PartiallyEmittedExpression;
4038        updatePartiallyEmittedExpression(node: PartiallyEmittedExpression, expression: Expression): PartiallyEmittedExpression;
4039        createCommaListExpression(elements: readonly Expression[]): CommaListExpression;
4040        updateCommaListExpression(node: CommaListExpression, elements: readonly Expression[]): CommaListExpression;
4041        createBundle(sourceFiles: readonly SourceFile[], prepends?: readonly (UnparsedSource | InputFiles)[]): Bundle;
4042        updateBundle(node: Bundle, sourceFiles: readonly SourceFile[], prepends?: readonly (UnparsedSource | InputFiles)[]): Bundle;
4043        createComma(left: Expression, right: Expression): BinaryExpression;
4044        createAssignment(left: ObjectLiteralExpression | ArrayLiteralExpression, right: Expression): DestructuringAssignment;
4045        createAssignment(left: Expression, right: Expression): AssignmentExpression<EqualsToken>;
4046        createLogicalOr(left: Expression, right: Expression): BinaryExpression;
4047        createLogicalAnd(left: Expression, right: Expression): BinaryExpression;
4048        createBitwiseOr(left: Expression, right: Expression): BinaryExpression;
4049        createBitwiseXor(left: Expression, right: Expression): BinaryExpression;
4050        createBitwiseAnd(left: Expression, right: Expression): BinaryExpression;
4051        createStrictEquality(left: Expression, right: Expression): BinaryExpression;
4052        createStrictInequality(left: Expression, right: Expression): BinaryExpression;
4053        createEquality(left: Expression, right: Expression): BinaryExpression;
4054        createInequality(left: Expression, right: Expression): BinaryExpression;
4055        createLessThan(left: Expression, right: Expression): BinaryExpression;
4056        createLessThanEquals(left: Expression, right: Expression): BinaryExpression;
4057        createGreaterThan(left: Expression, right: Expression): BinaryExpression;
4058        createGreaterThanEquals(left: Expression, right: Expression): BinaryExpression;
4059        createLeftShift(left: Expression, right: Expression): BinaryExpression;
4060        createRightShift(left: Expression, right: Expression): BinaryExpression;
4061        createUnsignedRightShift(left: Expression, right: Expression): BinaryExpression;
4062        createAdd(left: Expression, right: Expression): BinaryExpression;
4063        createSubtract(left: Expression, right: Expression): BinaryExpression;
4064        createMultiply(left: Expression, right: Expression): BinaryExpression;
4065        createDivide(left: Expression, right: Expression): BinaryExpression;
4066        createModulo(left: Expression, right: Expression): BinaryExpression;
4067        createExponent(left: Expression, right: Expression): BinaryExpression;
4068        createPrefixPlus(operand: Expression): PrefixUnaryExpression;
4069        createPrefixMinus(operand: Expression): PrefixUnaryExpression;
4070        createPrefixIncrement(operand: Expression): PrefixUnaryExpression;
4071        createPrefixDecrement(operand: Expression): PrefixUnaryExpression;
4072        createBitwiseNot(operand: Expression): PrefixUnaryExpression;
4073        createLogicalNot(operand: Expression): PrefixUnaryExpression;
4074        createPostfixIncrement(operand: Expression): PostfixUnaryExpression;
4075        createPostfixDecrement(operand: Expression): PostfixUnaryExpression;
4076        createImmediatelyInvokedFunctionExpression(statements: readonly Statement[]): CallExpression;
4077        createImmediatelyInvokedFunctionExpression(statements: readonly Statement[], param: ParameterDeclaration, paramValue: Expression): CallExpression;
4078        createImmediatelyInvokedArrowFunction(statements: readonly Statement[]): CallExpression;
4079        createImmediatelyInvokedArrowFunction(statements: readonly Statement[], param: ParameterDeclaration, paramValue: Expression): CallExpression;
4080        createVoidZero(): VoidExpression;
4081        createExportDefault(expression: Expression): ExportAssignment;
4082        createExternalModuleExport(exportName: Identifier): ExportDeclaration;
4083        restoreOuterExpressions(outerExpression: Expression | undefined, innerExpression: Expression, kinds?: OuterExpressionKinds): Expression;
4084    }
4085    export interface CoreTransformationContext {
4086        readonly factory: NodeFactory;
4087        /** Gets the compiler options supplied to the transformer. */
4088        getCompilerOptions(): CompilerOptions;
4089        /** Starts a new lexical environment. */
4090        startLexicalEnvironment(): void;
4091        /** Suspends the current lexical environment, usually after visiting a parameter list. */
4092        suspendLexicalEnvironment(): void;
4093        /** Resumes a suspended lexical environment, usually before visiting a function body. */
4094        resumeLexicalEnvironment(): void;
4095        /** Ends a lexical environment, returning any declarations. */
4096        endLexicalEnvironment(): Statement[] | undefined;
4097        /** Hoists a function declaration to the containing scope. */
4098        hoistFunctionDeclaration(node: FunctionDeclaration): void;
4099        /** Hoists a variable declaration to the containing scope. */
4100        hoistVariableDeclaration(node: Identifier): void;
4101    }
4102    export interface TransformationContext extends CoreTransformationContext {
4103        /** Records a request for a non-scoped emit helper in the current context. */
4104        requestEmitHelper(helper: EmitHelper): void;
4105        /** Gets and resets the requested non-scoped emit helpers. */
4106        readEmitHelpers(): EmitHelper[] | undefined;
4107        /** Enables expression substitutions in the pretty printer for the provided SyntaxKind. */
4108        enableSubstitution(kind: SyntaxKind): void;
4109        /** Determines whether expression substitutions are enabled for the provided node. */
4110        isSubstitutionEnabled(node: Node): boolean;
4111        /**
4112         * Hook used by transformers to substitute expressions just before they
4113         * are emitted by the pretty printer.
4114         *
4115         * NOTE: Transformation hooks should only be modified during `Transformer` initialization,
4116         * before returning the `NodeTransformer` callback.
4117         */
4118        onSubstituteNode: (hint: EmitHint, node: Node) => Node;
4119        /**
4120         * Enables before/after emit notifications in the pretty printer for the provided
4121         * SyntaxKind.
4122         */
4123        enableEmitNotification(kind: SyntaxKind): void;
4124        /**
4125         * Determines whether before/after emit notifications should be raised in the pretty
4126         * printer when it emits a node.
4127         */
4128        isEmitNotificationEnabled(node: Node): boolean;
4129        /**
4130         * Hook used to allow transformers to capture state before or after
4131         * the printer emits a node.
4132         *
4133         * NOTE: Transformation hooks should only be modified during `Transformer` initialization,
4134         * before returning the `NodeTransformer` callback.
4135         */
4136        onEmitNode: (hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) => void;
4137        /** Determines whether the lexical environment is suspended */
4138        isLexicalEnvironmentSuspended?(): boolean;
4139    }
4140    export interface TransformationResult<T extends Node> {
4141        /** Gets the transformed source files. */
4142        transformed: T[];
4143        /** Gets diagnostics for the transformation. */
4144        diagnostics?: DiagnosticWithLocation[];
4145        /**
4146         * Gets a substitute for a node, if one is available; otherwise, returns the original node.
4147         *
4148         * @param hint A hint as to the intended usage of the node.
4149         * @param node The node to substitute.
4150         */
4151        substituteNode(hint: EmitHint, node: Node): Node;
4152        /**
4153         * Emits a node with possible notification.
4154         *
4155         * @param hint A hint as to the intended usage of the node.
4156         * @param node The node to emit.
4157         * @param emitCallback A callback used to emit the node.
4158         */
4159        emitNodeWithNotification(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void): void;
4160        /**
4161         * Indicates if a given node needs an emit notification
4162         *
4163         * @param node The node to emit.
4164         */
4165        isEmitNotificationEnabled?(node: Node): boolean;
4166        /**
4167         * Clean up EmitNode entries on any parse-tree nodes.
4168         */
4169        dispose(): void;
4170    }
4171    /**
4172     * A function that is used to initialize and return a `Transformer` callback, which in turn
4173     * will be used to transform one or more nodes.
4174     */
4175    export type TransformerFactory<T extends Node> = (context: TransformationContext) => Transformer<T>;
4176    /**
4177     * A function that transforms a node.
4178     */
4179    export type Transformer<T extends Node> = (node: T) => T;
4180    /**
4181     * A function that accepts and possibly transforms a node.
4182     */
4183    export type Visitor = (node: Node) => VisitResult<Node>;
4184    export interface NodeVisitor {
4185        <T extends Node>(nodes: T, visitor: Visitor | undefined, test?: (node: Node) => boolean, lift?: (node: readonly Node[]) => T): T;
4186        <T extends Node>(nodes: T | undefined, visitor: Visitor | undefined, test?: (node: Node) => boolean, lift?: (node: readonly Node[]) => T): T | undefined;
4187    }
4188    export interface NodesVisitor {
4189        <T extends Node>(nodes: NodeArray<T>, visitor: Visitor | undefined, test?: (node: Node) => boolean, start?: number, count?: number): NodeArray<T>;
4190        <T extends Node>(nodes: NodeArray<T> | undefined, visitor: Visitor | undefined, test?: (node: Node) => boolean, start?: number, count?: number): NodeArray<T> | undefined;
4191    }
4192    export type VisitResult<T extends Node> = T | readonly T[] | undefined;
4193    export interface Printer {
4194        /**
4195         * Print a node and its subtree as-is, without any emit transformations.
4196         * @param hint A value indicating the purpose of a node. This is primarily used to
4197         * distinguish between an `Identifier` used in an expression position, versus an
4198         * `Identifier` used as an `IdentifierName` as part of a declaration. For most nodes you
4199         * should just pass `Unspecified`.
4200         * @param node The node to print. The node and its subtree are printed as-is, without any
4201         * emit transformations.
4202         * @param sourceFile A source file that provides context for the node. The source text of
4203         * the file is used to emit the original source content for literals and identifiers, while
4204         * the identifiers of the source file are used when generating unique names to avoid
4205         * collisions.
4206         */
4207        printNode(hint: EmitHint, node: Node, sourceFile: SourceFile): string;
4208        /**
4209         * Prints a list of nodes using the given format flags
4210         */
4211        printList<T extends Node>(format: ListFormat, list: NodeArray<T>, sourceFile: SourceFile): string;
4212        /**
4213         * Prints a source file as-is, without any emit transformations.
4214         */
4215        printFile(sourceFile: SourceFile): string;
4216        /**
4217         * Prints a bundle of source files as-is, without any emit transformations.
4218         */
4219        printBundle(bundle: Bundle): string;
4220        writeFile(sourceFile: SourceFile, writer: EmitTextWriter, sourceMapGenerator: SourceMapGenerator | undefined): void;
4221    }
4222    export interface PrintHandlers {
4223        /**
4224         * A hook used by the Printer when generating unique names to avoid collisions with
4225         * globally defined names that exist outside of the current source file.
4226         */
4227        hasGlobalName?(name: string): boolean;
4228        /**
4229         * A hook used by the Printer to provide notifications prior to emitting a node. A
4230         * compatible implementation **must** invoke `emitCallback` with the provided `hint` and
4231         * `node` values.
4232         * @param hint A hint indicating the intended purpose of the node.
4233         * @param node The node to emit.
4234         * @param emitCallback A callback that, when invoked, will emit the node.
4235         * @example
4236         * ```ts
4237         * var printer = createPrinter(printerOptions, {
4238         *   onEmitNode(hint, node, emitCallback) {
4239         *     // set up or track state prior to emitting the node...
4240         *     emitCallback(hint, node);
4241         *     // restore state after emitting the node...
4242         *   }
4243         * });
4244         * ```
4245         */
4246        onEmitNode?(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void): void;
4247        /**
4248         * A hook used to check if an emit notification is required for a node.
4249         * @param node The node to emit.
4250         */
4251        isEmitNotificationEnabled?(node: Node): boolean;
4252        /**
4253         * A hook used by the Printer to perform just-in-time substitution of a node. This is
4254         * primarily used by node transformations that need to substitute one node for another,
4255         * such as replacing `myExportedVar` with `exports.myExportedVar`.
4256         * @param hint A hint indicating the intended purpose of the node.
4257         * @param node The node to emit.
4258         * @example
4259         * ```ts
4260         * var printer = createPrinter(printerOptions, {
4261         *   substituteNode(hint, node) {
4262         *     // perform substitution if necessary...
4263         *     return node;
4264         *   }
4265         * });
4266         * ```
4267         */
4268        substituteNode?(hint: EmitHint, node: Node): Node;
4269    }
4270    export interface PrinterOptions {
4271        removeComments?: boolean;
4272        newLine?: NewLineKind;
4273        omitTrailingSemicolon?: boolean;
4274        noEmitHelpers?: boolean;
4275        sourceMap?: boolean;
4276        inlineSourceMap?: boolean;
4277        inlineSources?: boolean;
4278    }
4279    export interface RawSourceMap {
4280        version: 3;
4281        file: string;
4282        sourceRoot?: string | null;
4283        sources: string[];
4284        sourcesContent?: (string | null)[] | null;
4285        mappings: string;
4286        names?: string[] | null;
4287    }
4288    /**
4289     * Generates a source map.
4290     */
4291    export interface SourceMapGenerator {
4292        getSources(): readonly string[];
4293        /**
4294         * Adds a source to the source map.
4295         */
4296        addSource(fileName: string): number;
4297        /**
4298         * Set the content for a source.
4299         */
4300        setSourceContent(sourceIndex: number, content: string | null): void;
4301        /**
4302         * Adds a name.
4303         */
4304        addName(name: string): number;
4305        /**
4306         * Adds a mapping without source information.
4307         */
4308        addMapping(generatedLine: number, generatedCharacter: number): void;
4309        /**
4310         * Adds a mapping with source information.
4311         */
4312        addMapping(generatedLine: number, generatedCharacter: number, sourceIndex: number, sourceLine: number, sourceCharacter: number, nameIndex?: number): void;
4313        /**
4314         * Appends a source map.
4315         */
4316        appendSourceMap(generatedLine: number, generatedCharacter: number, sourceMap: RawSourceMap, sourceMapPath: string, start?: LineAndCharacter, end?: LineAndCharacter): void;
4317        /**
4318         * Gets the source map as a `RawSourceMap` object.
4319         */
4320        toJSON(): RawSourceMap;
4321        /**
4322         * Gets the string representation of the source map.
4323         */
4324        toString(): string;
4325    }
4326    export interface EmitTextWriter extends SymbolWriter {
4327        write(s: string): void;
4328        writeTrailingSemicolon(text: string): void;
4329        writeComment(text: string): void;
4330        getText(): string;
4331        rawWrite(s: string): void;
4332        writeLiteral(s: string): void;
4333        getTextPos(): number;
4334        getLine(): number;
4335        getColumn(): number;
4336        getIndent(): number;
4337        isAtStartOfLine(): boolean;
4338        hasTrailingComment(): boolean;
4339        hasTrailingWhitespace(): boolean;
4340        getTextPosWithWriteLine?(): number;
4341        nonEscapingWrite?(text: string): void;
4342    }
4343    export interface GetEffectiveTypeRootsHost {
4344        directoryExists?(directoryName: string): boolean;
4345        getCurrentDirectory?(): string;
4346    }
4347    export interface ModuleSpecifierResolutionHost {
4348        useCaseSensitiveFileNames?(): boolean;
4349        fileExists(path: string): boolean;
4350        getCurrentDirectory(): string;
4351        directoryExists?(path: string): boolean;
4352        readFile?(path: string): string | undefined;
4353        realpath?(path: string): string;
4354        getModuleSpecifierCache?(): ModuleSpecifierCache;
4355        getPackageJsonInfoCache?(): PackageJsonInfoCache | undefined;
4356        getGlobalTypingsCacheLocation?(): string | undefined;
4357        getNearestAncestorDirectoryWithPackageJson?(fileName: string, rootDir?: string): string | undefined;
4358        readonly redirectTargetsMap: RedirectTargetsMap;
4359        getProjectReferenceRedirect(fileName: string): string | undefined;
4360        isSourceOfProjectReferenceRedirect(fileName: string): boolean;
4361    }
4362    export interface ModulePath {
4363        path: string;
4364        isInNodeModules: boolean;
4365        isRedirect: boolean;
4366    }
4367    export interface ResolvedModuleSpecifierInfo {
4368        modulePaths: readonly ModulePath[] | undefined;
4369        moduleSpecifiers: readonly string[] | undefined;
4370        isBlockedByPackageJsonDependencies: boolean | undefined;
4371    }
4372    export interface ModuleSpecifierOptions {
4373        overrideImportMode?: SourceFile["impliedNodeFormat"];
4374    }
4375    export interface ModuleSpecifierCache {
4376        get(fromFileName: Path, toFileName: Path, preferences: UserPreferences, options: ModuleSpecifierOptions): Readonly<ResolvedModuleSpecifierInfo> | undefined;
4377        set(fromFileName: Path, toFileName: Path, preferences: UserPreferences, options: ModuleSpecifierOptions, modulePaths: readonly ModulePath[], moduleSpecifiers: readonly string[]): void;
4378        setBlockedByPackageJsonDependencies(fromFileName: Path, toFileName: Path, preferences: UserPreferences, options: ModuleSpecifierOptions, isBlockedByPackageJsonDependencies: boolean): void;
4379        setModulePaths(fromFileName: Path, toFileName: Path, preferences: UserPreferences, options: ModuleSpecifierOptions, modulePaths: readonly ModulePath[]): void;
4380        clear(): void;
4381        count(): number;
4382    }
4383    export interface SymbolTracker {
4384        trackSymbol?(symbol: Symbol, enclosingDeclaration: Node | undefined, meaning: SymbolFlags): boolean;
4385        reportInaccessibleThisError?(): void;
4386        reportPrivateInBaseOfClassExpression?(propertyName: string): void;
4387        reportInaccessibleUniqueSymbolError?(): void;
4388        reportCyclicStructureError?(): void;
4389        reportLikelyUnsafeImportRequiredError?(specifier: string): void;
4390        reportTruncationError?(): void;
4391        moduleResolverHost?: ModuleSpecifierResolutionHost & {
4392            getCommonSourceDirectory(): string;
4393        };
4394        trackReferencedAmbientModule?(decl: ModuleDeclaration, symbol: Symbol): void;
4395        trackExternalModuleSymbolOfImportTypeNode?(symbol: Symbol): void;
4396        reportNonlocalAugmentation?(containingFile: SourceFile, parentSymbol: Symbol, augmentingSymbol: Symbol): void;
4397        reportNonSerializableProperty?(propertyName: string): void;
4398        reportImportTypeNodeResolutionModeOverride?(): void;
4399    }
4400    export interface TextSpan {
4401        start: number;
4402        length: number;
4403    }
4404    export interface TextChangeRange {
4405        span: TextSpan;
4406        newLength: number;
4407    }
4408    export interface SyntaxList extends Node {
4409        kind: SyntaxKind.SyntaxList;
4410        _children: Node[];
4411    }
4412    export enum ListFormat {
4413        None = 0,
4414        SingleLine = 0,
4415        MultiLine = 1,
4416        PreserveLines = 2,
4417        LinesMask = 3,
4418        NotDelimited = 0,
4419        BarDelimited = 4,
4420        AmpersandDelimited = 8,
4421        CommaDelimited = 16,
4422        AsteriskDelimited = 32,
4423        DelimitersMask = 60,
4424        AllowTrailingComma = 64,
4425        Indented = 128,
4426        SpaceBetweenBraces = 256,
4427        SpaceBetweenSiblings = 512,
4428        Braces = 1024,
4429        Parenthesis = 2048,
4430        AngleBrackets = 4096,
4431        SquareBrackets = 8192,
4432        BracketsMask = 15360,
4433        OptionalIfUndefined = 16384,
4434        OptionalIfEmpty = 32768,
4435        Optional = 49152,
4436        PreferNewLine = 65536,
4437        NoTrailingNewLine = 131072,
4438        NoInterveningComments = 262144,
4439        NoSpaceIfEmpty = 524288,
4440        SingleElement = 1048576,
4441        SpaceAfterList = 2097152,
4442        Modifiers = 2359808,
4443        HeritageClauses = 512,
4444        SingleLineTypeLiteralMembers = 768,
4445        MultiLineTypeLiteralMembers = 32897,
4446        SingleLineTupleTypeElements = 528,
4447        MultiLineTupleTypeElements = 657,
4448        UnionTypeConstituents = 516,
4449        IntersectionTypeConstituents = 520,
4450        ObjectBindingPatternElements = 525136,
4451        ArrayBindingPatternElements = 524880,
4452        ObjectLiteralExpressionProperties = 526226,
4453        ImportClauseEntries = 526226,
4454        ArrayLiteralExpressionElements = 8914,
4455        CommaListElements = 528,
4456        CallExpressionArguments = 2576,
4457        NewExpressionArguments = 18960,
4458        TemplateExpressionSpans = 262144,
4459        SingleLineBlockStatements = 768,
4460        MultiLineBlockStatements = 129,
4461        VariableDeclarationList = 528,
4462        SingleLineFunctionBodyStatements = 768,
4463        MultiLineFunctionBodyStatements = 1,
4464        ClassHeritageClauses = 0,
4465        ClassMembers = 129,
4466        InterfaceMembers = 129,
4467        EnumMembers = 145,
4468        CaseBlockClauses = 129,
4469        NamedImportsOrExportsElements = 525136,
4470        JsxElementOrFragmentChildren = 262144,
4471        JsxElementAttributes = 262656,
4472        CaseOrDefaultClauseStatements = 163969,
4473        HeritageClauseTypes = 528,
4474        SourceFileStatements = 131073,
4475        Decorators = 2146305,
4476        TypeArguments = 53776,
4477        TypeParameters = 53776,
4478        Parameters = 2576,
4479        IndexSignatureParameters = 8848,
4480        JSDocComment = 33
4481    }
4482    export interface UserPreferences {
4483        readonly disableSuggestions?: boolean;
4484        readonly quotePreference?: "auto" | "double" | "single";
4485        readonly includeCompletionsForModuleExports?: boolean;
4486        readonly includeCompletionsForImportStatements?: boolean;
4487        readonly includeCompletionsWithSnippetText?: boolean;
4488        readonly includeAutomaticOptionalChainCompletions?: boolean;
4489        readonly includeCompletionsWithInsertText?: boolean;
4490        readonly includeCompletionsWithClassMemberSnippets?: boolean;
4491        readonly includeCompletionsWithObjectLiteralMethodSnippets?: boolean;
4492        readonly useLabelDetailsInCompletionEntries?: boolean;
4493        readonly allowIncompleteCompletions?: boolean;
4494        readonly importModuleSpecifierPreference?: "shortest" | "project-relative" | "relative" | "non-relative";
4495        /** Determines whether we import `foo/index.ts` as "foo", "foo/index", or "foo/index.js" */
4496        readonly importModuleSpecifierEnding?: "auto" | "minimal" | "index" | "js";
4497        readonly allowTextChangesInNewFiles?: boolean;
4498        readonly providePrefixAndSuffixTextForRename?: boolean;
4499        readonly includePackageJsonAutoImports?: "auto" | "on" | "off";
4500        readonly provideRefactorNotApplicableReason?: boolean;
4501        readonly jsxAttributeCompletionStyle?: "auto" | "braces" | "none";
4502        readonly includeInlayParameterNameHints?: "none" | "literals" | "all";
4503        readonly includeInlayParameterNameHintsWhenArgumentMatchesName?: boolean;
4504        readonly includeInlayFunctionParameterTypeHints?: boolean;
4505        readonly includeInlayVariableTypeHints?: boolean;
4506        readonly includeInlayVariableTypeHintsWhenTypeMatchesName?: boolean;
4507        readonly includeInlayPropertyDeclarationTypeHints?: boolean;
4508        readonly includeInlayFunctionLikeReturnTypeHints?: boolean;
4509        readonly includeInlayEnumMemberValueHints?: boolean;
4510        readonly allowRenameOfImportPath?: boolean;
4511        readonly autoImportFileExcludePatterns?: string[];
4512    }
4513    /** Represents a bigint literal value without requiring bigint support */
4514    export interface PseudoBigInt {
4515        negative: boolean;
4516        base10Value: string;
4517    }
4518    export {};
4519}
4520declare function setTimeout(handler: (...args: any[]) => void, timeout: number): any;
4521declare function clearTimeout(handle: any): void;
4522declare namespace ts {
4523    export enum FileWatcherEventKind {
4524        Created = 0,
4525        Changed = 1,
4526        Deleted = 2
4527    }
4528    export type FileWatcherCallback = (fileName: string, eventKind: FileWatcherEventKind, modifiedTime?: Date) => void;
4529    export type DirectoryWatcherCallback = (fileName: string) => void;
4530    export interface System {
4531        args: string[];
4532        newLine: string;
4533        useCaseSensitiveFileNames: boolean;
4534        write(s: string): void;
4535        writeOutputIsTTY?(): boolean;
4536        getWidthOfTerminal?(): number;
4537        readFile(path: string, encoding?: string): string | undefined;
4538        getFileSize?(path: string): number;
4539        writeFile(path: string, data: string, writeByteOrderMark?: boolean): void;
4540        /**
4541         * @pollingInterval - this parameter is used in polling-based watchers and ignored in watchers that
4542         * use native OS file watching
4543         */
4544        watchFile?(path: string, callback: FileWatcherCallback, pollingInterval?: number, options?: WatchOptions): FileWatcher;
4545        watchDirectory?(path: string, callback: DirectoryWatcherCallback, recursive?: boolean, options?: WatchOptions): FileWatcher;
4546        resolvePath(path: string): string;
4547        fileExists(path: string): boolean;
4548        directoryExists(path: string): boolean;
4549        createDirectory(path: string): void;
4550        getExecutingFilePath(): string;
4551        getCurrentDirectory(): string;
4552        getDirectories(path: string): string[];
4553        readDirectory(path: string, extensions?: readonly string[], exclude?: readonly string[], include?: readonly string[], depth?: number): string[];
4554        getModifiedTime?(path: string): Date | undefined;
4555        setModifiedTime?(path: string, time: Date): void;
4556        deleteFile?(path: string): void;
4557        /**
4558         * A good implementation is node.js' `crypto.createHash`. (https://nodejs.org/api/crypto.html#crypto_crypto_createhash_algorithm)
4559         */
4560        createHash?(data: string): string;
4561        /** This must be cryptographically secure. Only implement this method using `crypto.createHash("sha256")`. */
4562        createSHA256Hash?(data: string): string;
4563        getMemoryUsage?(): number;
4564        exit(exitCode?: number): void;
4565        realpath?(path: string): string;
4566        setTimeout?(callback: (...args: any[]) => void, ms: number, ...args: any[]): any;
4567        clearTimeout?(timeoutId: any): void;
4568        clearScreen?(): void;
4569        base64decode?(input: string): string;
4570        base64encode?(input: string): string;
4571    }
4572    export interface FileWatcher {
4573        close(): void;
4574    }
4575    export function getNodeMajorVersion(): number | undefined;
4576    export let sys: System;
4577    export {};
4578}
4579declare namespace ts {
4580    type ErrorCallback = (message: DiagnosticMessage, length: number) => void;
4581    interface Scanner {
4582        getStartPos(): number;
4583        getToken(): SyntaxKind;
4584        getTextPos(): number;
4585        getTokenPos(): number;
4586        getTokenText(): string;
4587        getTokenValue(): string;
4588        hasUnicodeEscape(): boolean;
4589        hasExtendedUnicodeEscape(): boolean;
4590        hasPrecedingLineBreak(): boolean;
4591        isIdentifier(): boolean;
4592        isReservedWord(): boolean;
4593        isUnterminated(): boolean;
4594        reScanGreaterToken(): SyntaxKind;
4595        reScanSlashToken(): SyntaxKind;
4596        reScanAsteriskEqualsToken(): SyntaxKind;
4597        reScanTemplateToken(isTaggedTemplate: boolean): SyntaxKind;
4598        reScanTemplateHeadOrNoSubstitutionTemplate(): SyntaxKind;
4599        scanJsxIdentifier(): SyntaxKind;
4600        scanJsxAttributeValue(): SyntaxKind;
4601        reScanJsxAttributeValue(): SyntaxKind;
4602        reScanJsxToken(allowMultilineJsxText?: boolean): JsxTokenSyntaxKind;
4603        reScanLessThanToken(): SyntaxKind;
4604        reScanHashToken(): SyntaxKind;
4605        reScanQuestionToken(): SyntaxKind;
4606        reScanInvalidIdentifier(): SyntaxKind;
4607        scanJsxToken(): JsxTokenSyntaxKind;
4608        scanJsDocToken(): JSDocSyntaxKind;
4609        scan(): SyntaxKind;
4610        getText(): string;
4611        setText(text: string | undefined, start?: number, length?: number): void;
4612        setOnError(onError: ErrorCallback | undefined): void;
4613        setScriptTarget(scriptTarget: ScriptTarget): void;
4614        setLanguageVariant(variant: LanguageVariant): void;
4615        setTextPos(textPos: number): void;
4616        lookAhead<T>(callback: () => T): T;
4617        scanRange<T>(start: number, length: number, callback: () => T): T;
4618        tryScan<T>(callback: () => T): T;
4619        setEtsContext(isEtsContext: boolean): void;
4620    }
4621    function tokenToString(t: SyntaxKind): string | undefined;
4622    function getPositionOfLineAndCharacter(sourceFile: SourceFileLike, line: number, character: number): number;
4623    function getLineAndCharacterOfPosition(sourceFile: SourceFileLike, position: number): LineAndCharacter;
4624    function isWhiteSpaceLike(ch: number): boolean;
4625    /** Does not include line breaks. For that, see isWhiteSpaceLike. */
4626    function isWhiteSpaceSingleLine(ch: number): boolean;
4627    function isLineBreak(ch: number): boolean;
4628    function couldStartTrivia(text: string, pos: number): boolean;
4629    function forEachLeadingCommentRange<U>(text: string, pos: number, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean) => U): U | undefined;
4630    function forEachLeadingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean, state: T) => U, state: T): U | undefined;
4631    function forEachTrailingCommentRange<U>(text: string, pos: number, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean) => U): U | undefined;
4632    function forEachTrailingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean, state: T) => U, state: T): U | undefined;
4633    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;
4634    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;
4635    function getLeadingCommentRanges(text: string, pos: number): CommentRange[] | undefined;
4636    function getTrailingCommentRanges(text: string, pos: number): CommentRange[] | undefined;
4637    /** Optionally, get the shebang */
4638    function getShebang(text: string): string | undefined;
4639    function isIdentifierStart(ch: number, languageVersion: ScriptTarget | undefined): boolean;
4640    function isIdentifierPart(ch: number, languageVersion: ScriptTarget | undefined, identifierVariant?: LanguageVariant): boolean;
4641    function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean, languageVariant?: LanguageVariant, textInitial?: string, onError?: ErrorCallback, start?: number, length?: number): Scanner;
4642}
4643declare namespace ts {
4644    function isExternalModuleNameRelative(moduleName: string): boolean;
4645    function sortAndDeduplicateDiagnostics<T extends Diagnostic>(diagnostics: readonly T[]): SortedReadonlyArray<T>;
4646    function getDefaultLibFileName(options: CompilerOptions): string;
4647    function textSpanEnd(span: TextSpan): number;
4648    function textSpanIsEmpty(span: TextSpan): boolean;
4649    function textSpanContainsPosition(span: TextSpan, position: number): boolean;
4650    function textSpanContainsTextSpan(span: TextSpan, other: TextSpan): boolean;
4651    function textSpanOverlapsWith(span: TextSpan, other: TextSpan): boolean;
4652    function textSpanOverlap(span1: TextSpan, span2: TextSpan): TextSpan | undefined;
4653    function textSpanIntersectsWithTextSpan(span: TextSpan, other: TextSpan): boolean;
4654    function textSpanIntersectsWith(span: TextSpan, start: number, length: number): boolean;
4655    function decodedTextSpanIntersectsWith(start1: number, length1: number, start2: number, length2: number): boolean;
4656    function textSpanIntersectsWithPosition(span: TextSpan, position: number): boolean;
4657    function textSpanIntersection(span1: TextSpan, span2: TextSpan): TextSpan | undefined;
4658    function createTextSpan(start: number, length: number): TextSpan;
4659    function createTextSpanFromBounds(start: number, end: number): TextSpan;
4660    function textChangeRangeNewSpan(range: TextChangeRange): TextSpan;
4661    function textChangeRangeIsUnchanged(range: TextChangeRange): boolean;
4662    function createTextChangeRange(span: TextSpan, newLength: number): TextChangeRange;
4663    let unchangedTextChangeRange: TextChangeRange;
4664    /**
4665     * Called to merge all the changes that occurred across several versions of a script snapshot
4666     * into a single change.  i.e. if a user keeps making successive edits to a script we will
4667     * have a text change from V1 to V2, V2 to V3, ..., Vn.
4668     *
4669     * This function will then merge those changes into a single change range valid between V1 and
4670     * Vn.
4671     */
4672    function collapseTextChangeRangesAcrossMultipleVersions(changes: readonly TextChangeRange[]): TextChangeRange;
4673    function getTypeParameterOwner(d: Declaration): Declaration | undefined;
4674    type ParameterPropertyDeclaration = ParameterDeclaration & {
4675        parent: ConstructorDeclaration;
4676        name: Identifier;
4677    };
4678    function isParameterPropertyDeclaration(node: Node, parent: Node): node is ParameterPropertyDeclaration;
4679    function isEmptyBindingPattern(node: BindingName): node is BindingPattern;
4680    function isEmptyBindingElement(node: BindingElement): boolean;
4681    function walkUpBindingElementsAndPatterns(binding: BindingElement): VariableDeclaration | ParameterDeclaration;
4682    function getCombinedModifierFlags(node: Declaration): ModifierFlags;
4683    function getCombinedNodeFlags(node: Node): NodeFlags;
4684    /**
4685     * Checks to see if the locale is in the appropriate format,
4686     * and if it is, attempts to set the appropriate language.
4687     */
4688    function validateLocaleAndSetLanguage(locale: string, sys: {
4689        getExecutingFilePath(): string;
4690        resolvePath(path: string): string;
4691        fileExists(fileName: string): boolean;
4692        readFile(fileName: string): string | undefined;
4693    }, errors?: Push<Diagnostic>): void;
4694    function getOriginalNode(node: Node): Node;
4695    function getOriginalNode<T extends Node>(node: Node, nodeTest: (node: Node) => node is T): T;
4696    function getOriginalNode(node: Node | undefined): Node | undefined;
4697    function getOriginalNode<T extends Node>(node: Node | undefined, nodeTest: (node: Node | undefined) => node is T): T | undefined;
4698    /**
4699     * Iterates through the parent chain of a node and performs the callback on each parent until the callback
4700     * returns a truthy value, then returns that value.
4701     * If no such value is found, it applies the callback until the parent pointer is undefined or the callback returns "quit"
4702     * At that point findAncestor returns undefined.
4703     */
4704    function findAncestor<T extends Node>(node: Node | undefined, callback: (element: Node) => element is T): T | undefined;
4705    function findAncestor(node: Node | undefined, callback: (element: Node) => boolean | "quit"): Node | undefined;
4706    /**
4707     * Gets a value indicating whether a node originated in the parse tree.
4708     *
4709     * @param node The node to test.
4710     */
4711    function isParseTreeNode(node: Node): boolean;
4712    /**
4713     * Gets the original parse tree node for a node.
4714     *
4715     * @param node The original node.
4716     * @returns The original parse tree node if found; otherwise, undefined.
4717     */
4718    function getParseTreeNode(node: Node | undefined): Node | undefined;
4719    /**
4720     * Gets the original parse tree node for a node.
4721     *
4722     * @param node The original node.
4723     * @param nodeTest A callback used to ensure the correct type of parse tree node is returned.
4724     * @returns The original parse tree node if found; otherwise, undefined.
4725     */
4726    function getParseTreeNode<T extends Node>(node: T | undefined, nodeTest?: (node: Node) => node is T): T | undefined;
4727    /** Add an extra underscore to identifiers that start with two underscores to avoid issues with magic names like '__proto__' */
4728    function escapeLeadingUnderscores(identifier: string): __String;
4729    /**
4730     * Remove extra underscore from escaped identifier text content.
4731     *
4732     * @param identifier The escaped identifier text.
4733     * @returns The unescaped identifier text.
4734     */
4735    function unescapeLeadingUnderscores(identifier: __String): string;
4736    function idText(identifierOrPrivateName: Identifier | PrivateIdentifier): string;
4737    function symbolName(symbol: Symbol): string;
4738    function getNameOfJSDocTypedef(declaration: JSDocTypedefTag): Identifier | PrivateIdentifier | undefined;
4739    function getNameOfDeclaration(declaration: Declaration | Expression | undefined): DeclarationName | undefined;
4740    function getDecorators(node: HasDecorators): readonly Decorator[] | undefined;
4741    function getModifiers(node: HasModifiers): readonly Modifier[] | undefined;
4742    function getAllDecorators(node: Node | undefined): readonly Decorator[];
4743    function getIllegalDecorators(node: HasIllegalDecorators): readonly Decorator[] | undefined;
4744    /**
4745     * Gets the JSDoc parameter tags for the node if present.
4746     *
4747     * @remarks Returns any JSDoc param tag whose name matches the provided
4748     * parameter, whether a param tag on a containing function
4749     * expression, or a param tag on a variable declaration whose
4750     * initializer is the containing function. The tags closest to the
4751     * node are returned first, so in the previous example, the param
4752     * tag on the containing function expression would be first.
4753     *
4754     * For binding patterns, parameter tags are matched by position.
4755     */
4756    function getJSDocParameterTags(param: ParameterDeclaration): readonly JSDocParameterTag[];
4757    /**
4758     * Gets the JSDoc type parameter tags for the node if present.
4759     *
4760     * @remarks Returns any JSDoc template tag whose names match the provided
4761     * parameter, whether a template tag on a containing function
4762     * expression, or a template tag on a variable declaration whose
4763     * initializer is the containing function. The tags closest to the
4764     * node are returned first, so in the previous example, the template
4765     * tag on the containing function expression would be first.
4766     */
4767    function getJSDocTypeParameterTags(param: TypeParameterDeclaration): readonly JSDocTemplateTag[];
4768    /**
4769     * Return true if the node has JSDoc parameter tags.
4770     *
4771     * @remarks Includes parameter tags that are not directly on the node,
4772     * for example on a variable declaration whose initializer is a function expression.
4773     */
4774    function hasJSDocParameterTags(node: FunctionLikeDeclaration | SignatureDeclaration): boolean;
4775    /** Gets the JSDoc augments tag for the node if present */
4776    function getJSDocAugmentsTag(node: Node): JSDocAugmentsTag | undefined;
4777    /** Gets the JSDoc implements tags for the node if present */
4778    function getJSDocImplementsTags(node: Node): readonly JSDocImplementsTag[];
4779    /** Gets the JSDoc class tag for the node if present */
4780    function getJSDocClassTag(node: Node): JSDocClassTag | undefined;
4781    /** Gets the JSDoc public tag for the node if present */
4782    function getJSDocPublicTag(node: Node): JSDocPublicTag | undefined;
4783    /** Gets the JSDoc private tag for the node if present */
4784    function getJSDocPrivateTag(node: Node): JSDocPrivateTag | undefined;
4785    /** Gets the JSDoc protected tag for the node if present */
4786    function getJSDocProtectedTag(node: Node): JSDocProtectedTag | undefined;
4787    /** Gets the JSDoc protected tag for the node if present */
4788    function getJSDocReadonlyTag(node: Node): JSDocReadonlyTag | undefined;
4789    function getJSDocOverrideTagNoCache(node: Node): JSDocOverrideTag | undefined;
4790    /** Gets the JSDoc deprecated tag for the node if present */
4791    function getJSDocDeprecatedTag(node: Node): JSDocDeprecatedTag | undefined;
4792    /** Gets the JSDoc enum tag for the node if present */
4793    function getJSDocEnumTag(node: Node): JSDocEnumTag | undefined;
4794    /** Gets the JSDoc this tag for the node if present */
4795    function getJSDocThisTag(node: Node): JSDocThisTag | undefined;
4796    /** Gets the JSDoc return tag for the node if present */
4797    function getJSDocReturnTag(node: Node): JSDocReturnTag | undefined;
4798    /** Gets the JSDoc template tag for the node if present */
4799    function getJSDocTemplateTag(node: Node): JSDocTemplateTag | undefined;
4800    /** Gets the JSDoc type tag for the node if present and valid */
4801    function getJSDocTypeTag(node: Node): JSDocTypeTag | undefined;
4802    /**
4803     * Gets the type node for the node if provided via JSDoc.
4804     *
4805     * @remarks The search includes any JSDoc param tag that relates
4806     * to the provided parameter, for example a type tag on the
4807     * parameter itself, or a param tag on a containing function
4808     * expression, or a param tag on a variable declaration whose
4809     * initializer is the containing function. The tags closest to the
4810     * node are examined first, so in the previous example, the type
4811     * tag directly on the node would be returned.
4812     */
4813    function getJSDocType(node: Node): TypeNode | undefined;
4814    /**
4815     * Gets the return type node for the node if provided via JSDoc return tag or type tag.
4816     *
4817     * @remarks `getJSDocReturnTag` just gets the whole JSDoc tag. This function
4818     * gets the type from inside the braces, after the fat arrow, etc.
4819     */
4820    function getJSDocReturnType(node: Node): TypeNode | undefined;
4821    /** Get all JSDoc tags related to a node, including those on parent nodes. */
4822    function getJSDocTags(node: Node): readonly JSDocTag[];
4823    /** Gets all JSDoc tags that match a specified predicate */
4824    function getAllJSDocTags<T extends JSDocTag>(node: Node, predicate: (tag: JSDocTag) => tag is T): readonly T[];
4825    /** Gets all JSDoc tags of a specified kind */
4826    function getAllJSDocTagsOfKind(node: Node, kind: SyntaxKind): readonly JSDocTag[];
4827    /** Gets the text of a jsdoc comment, flattening links to their text. */
4828    function getTextOfJSDocComment(comment?: string | NodeArray<JSDocComment>): string | undefined;
4829    /**
4830     * Gets the effective type parameters. If the node was parsed in a
4831     * JavaScript file, gets the type parameters from the `@template` tag from JSDoc.
4832     *
4833     * This does *not* return type parameters from a jsdoc reference to a generic type, eg
4834     *
4835     * type Id = <T>(x: T) => T
4836     * /** @type {Id} /
4837     * function id(x) { return x }
4838     */
4839    function getEffectiveTypeParameterDeclarations(node: DeclarationWithTypeParameters): readonly TypeParameterDeclaration[];
4840    function getEffectiveConstraintOfTypeParameter(node: TypeParameterDeclaration): TypeNode | undefined;
4841    function isMemberName(node: Node): node is MemberName;
4842    function isPropertyAccessChain(node: Node): node is PropertyAccessChain;
4843    function isElementAccessChain(node: Node): node is ElementAccessChain;
4844    function isCallChain(node: Node): node is CallChain;
4845    function isOptionalChain(node: Node): node is PropertyAccessChain | ElementAccessChain | CallChain | NonNullChain;
4846    function isNullishCoalesce(node: Node): boolean;
4847    function isConstTypeReference(node: Node): boolean;
4848    function skipPartiallyEmittedExpressions(node: Expression): Expression;
4849    function skipPartiallyEmittedExpressions(node: Node): Node;
4850    function isNonNullChain(node: Node): node is NonNullChain;
4851    function isBreakOrContinueStatement(node: Node): node is BreakOrContinueStatement;
4852    function isNamedExportBindings(node: Node): node is NamedExportBindings;
4853    function isUnparsedTextLike(node: Node): node is UnparsedTextLike;
4854    function isUnparsedNode(node: Node): node is UnparsedNode;
4855    function isJSDocPropertyLikeTag(node: Node): node is JSDocPropertyLikeTag;
4856    /**
4857     * True if kind is of some token syntax kind.
4858     * For example, this is true for an IfKeyword but not for an IfStatement.
4859     * Literals are considered tokens, except TemplateLiteral, but does include TemplateHead/Middle/Tail.
4860     */
4861    function isTokenKind(kind: SyntaxKind): boolean;
4862    /**
4863     * True if node is of some token syntax kind.
4864     * For example, this is true for an IfKeyword but not for an IfStatement.
4865     * Literals are considered tokens, except TemplateLiteral, but does include TemplateHead/Middle/Tail.
4866     */
4867    function isToken(n: Node): boolean;
4868    function isLiteralExpression(node: Node): node is LiteralExpression;
4869    function isTemplateLiteralToken(node: Node): node is TemplateLiteralToken;
4870    function isTemplateMiddleOrTemplateTail(node: Node): node is TemplateMiddle | TemplateTail;
4871    function isImportOrExportSpecifier(node: Node): node is ImportSpecifier | ExportSpecifier;
4872    function isTypeOnlyImportOrExportDeclaration(node: Node): node is TypeOnlyAliasDeclaration;
4873    function isAssertionKey(node: Node): node is AssertionKey;
4874    function isStringTextContainingNode(node: Node): node is StringLiteral | TemplateLiteralToken;
4875    function isModifier(node: Node): node is Modifier;
4876    function isEntityName(node: Node): node is EntityName;
4877    function isPropertyName(node: Node): node is PropertyName;
4878    function isBindingName(node: Node): node is BindingName;
4879    function isFunctionLike(node: Node | undefined): node is SignatureDeclaration;
4880    function isClassElement(node: Node): node is ClassElement;
4881    function isClassLike(node: Node): node is ClassLikeDeclaration;
4882    function isStruct(node: Node): node is StructDeclaration;
4883    function isAccessor(node: Node): node is AccessorDeclaration;
4884    function isAutoAccessorPropertyDeclaration(node: Node): node is AutoAccessorPropertyDeclaration;
4885    function isModifierLike(node: Node): node is ModifierLike;
4886    function isTypeElement(node: Node): node is TypeElement;
4887    function isClassOrTypeElement(node: Node): node is ClassElement | TypeElement;
4888    function isObjectLiteralElementLike(node: Node): node is ObjectLiteralElementLike;
4889    /**
4890     * Node test that determines whether a node is a valid type node.
4891     * This differs from the `isPartOfTypeNode` function which determines whether a node is *part*
4892     * of a TypeNode.
4893     */
4894    function isTypeNode(node: Node): node is TypeNode;
4895    function isFunctionOrConstructorTypeNode(node: Node): node is FunctionTypeNode | ConstructorTypeNode;
4896    function isPropertyAccessOrQualifiedName(node: Node): node is PropertyAccessExpression | QualifiedName;
4897    function isCallLikeExpression(node: Node): node is CallLikeExpression;
4898    function isCallOrNewExpression(node: Node): node is CallExpression | NewExpression;
4899    function isTemplateLiteral(node: Node): node is TemplateLiteral;
4900    function isAssertionExpression(node: Node): node is AssertionExpression;
4901    function isIterationStatement(node: Node, lookInLabeledStatements: false): node is IterationStatement;
4902    function isIterationStatement(node: Node, lookInLabeledStatements: boolean): node is IterationStatement | LabeledStatement;
4903    function isJsxOpeningLikeElement(node: Node): node is JsxOpeningLikeElement;
4904    function isCaseOrDefaultClause(node: Node): node is CaseOrDefaultClause;
4905    /** True if node is of a kind that may contain comment text. */
4906    function isJSDocCommentContainingNode(node: Node): boolean;
4907    function isSetAccessor(node: Node): node is SetAccessorDeclaration;
4908    function isGetAccessor(node: Node): node is GetAccessorDeclaration;
4909    /** True if has initializer node attached to it. */
4910    function hasOnlyExpressionInitializer(node: Node): node is HasExpressionInitializer;
4911    function isObjectLiteralElement(node: Node): node is ObjectLiteralElement;
4912    function isStringLiteralLike(node: Node): node is StringLiteralLike;
4913    function isJSDocLinkLike(node: Node): node is JSDocLink | JSDocLinkCode | JSDocLinkPlain;
4914    function hasRestParameter(s: SignatureDeclaration | JSDocSignature): boolean;
4915    function isRestParameter(node: ParameterDeclaration | JSDocParameterTag): boolean;
4916}
4917declare namespace ts {
4918    function getLeadingCommentRangesOfNode(node: Node, sourceFileOfNode: SourceFile): CommentRange[] | undefined;
4919    function createTextWriter(newLine: string): EmitTextWriter;
4920    /**
4921     * Bypasses immutability and directly sets the `parent` property of each `Node` recursively.
4922     * @param rootNode The root node from which to start the recursion.
4923     * @param incremental When `true`, only recursively descends through nodes whose `parent` pointers are incorrect.
4924     * This allows us to quickly bail out of setting `parent` for subtrees during incremental parsing.
4925     */
4926    function setParentRecursive<T extends Node>(rootNode: T, incremental: boolean): T;
4927    function setParentRecursive<T extends Node>(rootNode: T | undefined, incremental: boolean): T | undefined;
4928}
4929declare namespace ts {
4930    const factory: NodeFactory;
4931    function createUnparsedSourceFile(text: string): UnparsedSource;
4932    function createUnparsedSourceFile(inputFile: InputFiles, type: "js" | "dts", stripInternal?: boolean): UnparsedSource;
4933    function createUnparsedSourceFile(text: string, mapPath: string | undefined, map: string | undefined): UnparsedSource;
4934    function createInputFiles(javascriptText: string, declarationText: string): InputFiles;
4935    function createInputFiles(readFileText: (path: string) => string | undefined, javascriptPath: string, javascriptMapPath: string | undefined, declarationPath: string, declarationMapPath: string | undefined, buildInfoPath: string | undefined): InputFiles;
4936    function createInputFiles(javascriptText: string, declarationText: string, javascriptMapPath: string | undefined, javascriptMapText: string | undefined, declarationMapPath: string | undefined, declarationMapText: string | undefined): InputFiles;
4937    /**
4938     * Create an external source map source file reference
4939     */
4940    function createSourceMapSource(fileName: string, text: string, skipTrivia?: (pos: number) => number): SourceMapSource;
4941    function setOriginalNode<T extends Node>(node: T, original: Node | undefined): T;
4942}
4943declare namespace ts {
4944    /**
4945     * Clears any `EmitNode` entries from parse-tree nodes.
4946     * @param sourceFile A source file.
4947     */
4948    function disposeEmitNodes(sourceFile: SourceFile | undefined): void;
4949    /**
4950     * Sets flags that control emit behavior of a node.
4951     */
4952    function setEmitFlags<T extends Node>(node: T, emitFlags: EmitFlags): T;
4953    /**
4954     * Gets a custom text range to use when emitting source maps.
4955     */
4956    function getSourceMapRange(node: Node): SourceMapRange;
4957    /**
4958     * Sets a custom text range to use when emitting source maps.
4959     */
4960    function setSourceMapRange<T extends Node>(node: T, range: SourceMapRange | undefined): T;
4961    /**
4962     * Gets the TextRange to use for source maps for a token of a node.
4963     */
4964    function getTokenSourceMapRange(node: Node, token: SyntaxKind): SourceMapRange | undefined;
4965    /**
4966     * Sets the TextRange to use for source maps for a token of a node.
4967     */
4968    function setTokenSourceMapRange<T extends Node>(node: T, token: SyntaxKind, range: SourceMapRange | undefined): T;
4969    /**
4970     * Gets a custom text range to use when emitting comments.
4971     */
4972    function getCommentRange(node: Node): TextRange;
4973    /**
4974     * Sets a custom text range to use when emitting comments.
4975     */
4976    function setCommentRange<T extends Node>(node: T, range: TextRange): T;
4977    function getSyntheticLeadingComments(node: Node): SynthesizedComment[] | undefined;
4978    function setSyntheticLeadingComments<T extends Node>(node: T, comments: SynthesizedComment[] | undefined): T;
4979    function addSyntheticLeadingComment<T extends Node>(node: T, kind: SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia, text: string, hasTrailingNewLine?: boolean): T;
4980    function getSyntheticTrailingComments(node: Node): SynthesizedComment[] | undefined;
4981    function setSyntheticTrailingComments<T extends Node>(node: T, comments: SynthesizedComment[] | undefined): T;
4982    function addSyntheticTrailingComment<T extends Node>(node: T, kind: SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia, text: string, hasTrailingNewLine?: boolean): T;
4983    function moveSyntheticComments<T extends Node>(node: T, original: Node): T;
4984    /**
4985     * Gets the constant value to emit for an expression representing an enum.
4986     */
4987    function getConstantValue(node: AccessExpression): string | number | undefined;
4988    /**
4989     * Sets the constant value to emit for an expression.
4990     */
4991    function setConstantValue(node: AccessExpression, value: string | number): AccessExpression;
4992    /**
4993     * Adds an EmitHelper to a node.
4994     */
4995    function addEmitHelper<T extends Node>(node: T, helper: EmitHelper): T;
4996    /**
4997     * Add EmitHelpers to a node.
4998     */
4999    function addEmitHelpers<T extends Node>(node: T, helpers: EmitHelper[] | undefined): T;
5000    /**
5001     * Removes an EmitHelper from a node.
5002     */
5003    function removeEmitHelper(node: Node, helper: EmitHelper): boolean;
5004    /**
5005     * Gets the EmitHelpers of a node.
5006     */
5007    function getEmitHelpers(node: Node): EmitHelper[] | undefined;
5008    /**
5009     * Moves matching emit helpers from a source node to a target node.
5010     */
5011    function moveEmitHelpers(source: Node, target: Node, predicate: (helper: EmitHelper) => boolean): void;
5012}
5013declare namespace ts {
5014    function isNumericLiteral(node: Node): node is NumericLiteral;
5015    function isBigIntLiteral(node: Node): node is BigIntLiteral;
5016    function isStringLiteral(node: Node): node is StringLiteral;
5017    function isJsxText(node: Node): node is JsxText;
5018    function isRegularExpressionLiteral(node: Node): node is RegularExpressionLiteral;
5019    function isNoSubstitutionTemplateLiteral(node: Node): node is NoSubstitutionTemplateLiteral;
5020    function isTemplateHead(node: Node): node is TemplateHead;
5021    function isTemplateMiddle(node: Node): node is TemplateMiddle;
5022    function isTemplateTail(node: Node): node is TemplateTail;
5023    function isDotDotDotToken(node: Node): node is DotDotDotToken;
5024    function isPlusToken(node: Node): node is PlusToken;
5025    function isMinusToken(node: Node): node is MinusToken;
5026    function isAsteriskToken(node: Node): node is AsteriskToken;
5027    function isIdentifier(node: Node): node is Identifier;
5028    function isPrivateIdentifier(node: Node): node is PrivateIdentifier;
5029    function isQualifiedName(node: Node): node is QualifiedName;
5030    function isComputedPropertyName(node: Node): node is ComputedPropertyName;
5031    function isTypeParameterDeclaration(node: Node): node is TypeParameterDeclaration;
5032    function isParameter(node: Node): node is ParameterDeclaration;
5033    function isDecorator(node: Node): node is Decorator;
5034    function isPropertySignature(node: Node): node is PropertySignature;
5035    function isPropertyDeclaration(node: Node): node is PropertyDeclaration;
5036    function isMethodSignature(node: Node): node is MethodSignature;
5037    function isMethodDeclaration(node: Node): node is MethodDeclaration;
5038    function isClassStaticBlockDeclaration(node: Node): node is ClassStaticBlockDeclaration;
5039    function isConstructorDeclaration(node: Node): node is ConstructorDeclaration;
5040    function isGetAccessorDeclaration(node: Node): node is GetAccessorDeclaration;
5041    function isSetAccessorDeclaration(node: Node): node is SetAccessorDeclaration;
5042    function isCallSignatureDeclaration(node: Node): node is CallSignatureDeclaration;
5043    function isConstructSignatureDeclaration(node: Node): node is ConstructSignatureDeclaration;
5044    function isIndexSignatureDeclaration(node: Node): node is IndexSignatureDeclaration;
5045    function isTypePredicateNode(node: Node): node is TypePredicateNode;
5046    function isTypeReferenceNode(node: Node): node is TypeReferenceNode;
5047    function isFunctionTypeNode(node: Node): node is FunctionTypeNode;
5048    function isConstructorTypeNode(node: Node): node is ConstructorTypeNode;
5049    function isTypeQueryNode(node: Node): node is TypeQueryNode;
5050    function isTypeLiteralNode(node: Node): node is TypeLiteralNode;
5051    function isArrayTypeNode(node: Node): node is ArrayTypeNode;
5052    function isTupleTypeNode(node: Node): node is TupleTypeNode;
5053    function isNamedTupleMember(node: Node): node is NamedTupleMember;
5054    function isOptionalTypeNode(node: Node): node is OptionalTypeNode;
5055    function isRestTypeNode(node: Node): node is RestTypeNode;
5056    function isUnionTypeNode(node: Node): node is UnionTypeNode;
5057    function isIntersectionTypeNode(node: Node): node is IntersectionTypeNode;
5058    function isConditionalTypeNode(node: Node): node is ConditionalTypeNode;
5059    function isInferTypeNode(node: Node): node is InferTypeNode;
5060    function isParenthesizedTypeNode(node: Node): node is ParenthesizedTypeNode;
5061    function isThisTypeNode(node: Node): node is ThisTypeNode;
5062    function isTypeOperatorNode(node: Node): node is TypeOperatorNode;
5063    function isIndexedAccessTypeNode(node: Node): node is IndexedAccessTypeNode;
5064    function isMappedTypeNode(node: Node): node is MappedTypeNode;
5065    function isLiteralTypeNode(node: Node): node is LiteralTypeNode;
5066    function isImportTypeNode(node: Node): node is ImportTypeNode;
5067    function isTemplateLiteralTypeSpan(node: Node): node is TemplateLiteralTypeSpan;
5068    function isTemplateLiteralTypeNode(node: Node): node is TemplateLiteralTypeNode;
5069    function isObjectBindingPattern(node: Node): node is ObjectBindingPattern;
5070    function isArrayBindingPattern(node: Node): node is ArrayBindingPattern;
5071    function isBindingElement(node: Node): node is BindingElement;
5072    function isArrayLiteralExpression(node: Node): node is ArrayLiteralExpression;
5073    function isObjectLiteralExpression(node: Node): node is ObjectLiteralExpression;
5074    function isPropertyAccessExpression(node: Node): node is PropertyAccessExpression;
5075    function isElementAccessExpression(node: Node): node is ElementAccessExpression;
5076    function isCallExpression(node: Node): node is CallExpression;
5077    function isNewExpression(node: Node): node is NewExpression;
5078    function isTaggedTemplateExpression(node: Node): node is TaggedTemplateExpression;
5079    function isTypeAssertionExpression(node: Node): node is TypeAssertion;
5080    function isParenthesizedExpression(node: Node): node is ParenthesizedExpression;
5081    function isFunctionExpression(node: Node): node is FunctionExpression;
5082    function isEtsComponentExpression(node: Node): node is EtsComponentExpression;
5083    function isArrowFunction(node: Node): node is ArrowFunction;
5084    function isDeleteExpression(node: Node): node is DeleteExpression;
5085    function isTypeOfExpression(node: Node): node is TypeOfExpression;
5086    function isVoidExpression(node: Node): node is VoidExpression;
5087    function isAwaitExpression(node: Node): node is AwaitExpression;
5088    function isPrefixUnaryExpression(node: Node): node is PrefixUnaryExpression;
5089    function isPostfixUnaryExpression(node: Node): node is PostfixUnaryExpression;
5090    function isBinaryExpression(node: Node): node is BinaryExpression;
5091    function isConditionalExpression(node: Node): node is ConditionalExpression;
5092    function isTemplateExpression(node: Node): node is TemplateExpression;
5093    function isYieldExpression(node: Node): node is YieldExpression;
5094    function isSpreadElement(node: Node): node is SpreadElement;
5095    function isClassExpression(node: Node): node is ClassExpression;
5096    function isOmittedExpression(node: Node): node is OmittedExpression;
5097    function isExpressionWithTypeArguments(node: Node): node is ExpressionWithTypeArguments;
5098    function isAsExpression(node: Node): node is AsExpression;
5099    function isSatisfiesExpression(node: Node): node is SatisfiesExpression;
5100    function isNonNullExpression(node: Node): node is NonNullExpression;
5101    function isMetaProperty(node: Node): node is MetaProperty;
5102    function isSyntheticExpression(node: Node): node is SyntheticExpression;
5103    function isPartiallyEmittedExpression(node: Node): node is PartiallyEmittedExpression;
5104    function isCommaListExpression(node: Node): node is CommaListExpression;
5105    function isTemplateSpan(node: Node): node is TemplateSpan;
5106    function isSemicolonClassElement(node: Node): node is SemicolonClassElement;
5107    function isBlock(node: Node): node is Block;
5108    function isVariableStatement(node: Node): node is VariableStatement;
5109    function isEmptyStatement(node: Node): node is EmptyStatement;
5110    function isExpressionStatement(node: Node): node is ExpressionStatement;
5111    function isIfStatement(node: Node): node is IfStatement;
5112    function isDoStatement(node: Node): node is DoStatement;
5113    function isWhileStatement(node: Node): node is WhileStatement;
5114    function isForStatement(node: Node): node is ForStatement;
5115    function isForInStatement(node: Node): node is ForInStatement;
5116    function isForOfStatement(node: Node): node is ForOfStatement;
5117    function isContinueStatement(node: Node): node is ContinueStatement;
5118    function isBreakStatement(node: Node): node is BreakStatement;
5119    function isReturnStatement(node: Node): node is ReturnStatement;
5120    function isWithStatement(node: Node): node is WithStatement;
5121    function isSwitchStatement(node: Node): node is SwitchStatement;
5122    function isLabeledStatement(node: Node): node is LabeledStatement;
5123    function isThrowStatement(node: Node): node is ThrowStatement;
5124    function isTryStatement(node: Node): node is TryStatement;
5125    function isDebuggerStatement(node: Node): node is DebuggerStatement;
5126    function isVariableDeclaration(node: Node): node is VariableDeclaration;
5127    function isVariableDeclarationList(node: Node): node is VariableDeclarationList;
5128    function isFunctionDeclaration(node: Node): node is FunctionDeclaration;
5129    function isClassDeclaration(node: Node): node is ClassDeclaration;
5130    function isStructDeclaration(node: Node): node is StructDeclaration;
5131    function isInterfaceDeclaration(node: Node): node is InterfaceDeclaration;
5132    function isTypeAliasDeclaration(node: Node): node is TypeAliasDeclaration;
5133    function isEnumDeclaration(node: Node): node is EnumDeclaration;
5134    function isModuleDeclaration(node: Node): node is ModuleDeclaration;
5135    function isModuleBlock(node: Node): node is ModuleBlock;
5136    function isCaseBlock(node: Node): node is CaseBlock;
5137    function isNamespaceExportDeclaration(node: Node): node is NamespaceExportDeclaration;
5138    function isImportEqualsDeclaration(node: Node): node is ImportEqualsDeclaration;
5139    function isImportDeclaration(node: Node): node is ImportDeclaration;
5140    function isImportClause(node: Node): node is ImportClause;
5141    function isImportTypeAssertionContainer(node: Node): node is ImportTypeAssertionContainer;
5142    function isAssertClause(node: Node): node is AssertClause;
5143    function isAssertEntry(node: Node): node is AssertEntry;
5144    function isNamespaceImport(node: Node): node is NamespaceImport;
5145    function isNamespaceExport(node: Node): node is NamespaceExport;
5146    function isNamedImports(node: Node): node is NamedImports;
5147    function isImportSpecifier(node: Node): node is ImportSpecifier;
5148    function isExportAssignment(node: Node): node is ExportAssignment;
5149    function isExportDeclaration(node: Node): node is ExportDeclaration;
5150    function isNamedExports(node: Node): node is NamedExports;
5151    function isExportSpecifier(node: Node): node is ExportSpecifier;
5152    function isMissingDeclaration(node: Node): node is MissingDeclaration;
5153    function isNotEmittedStatement(node: Node): node is NotEmittedStatement;
5154    function isExternalModuleReference(node: Node): node is ExternalModuleReference;
5155    function isJsxElement(node: Node): node is JsxElement;
5156    function isJsxSelfClosingElement(node: Node): node is JsxSelfClosingElement;
5157    function isJsxOpeningElement(node: Node): node is JsxOpeningElement;
5158    function isJsxClosingElement(node: Node): node is JsxClosingElement;
5159    function isJsxFragment(node: Node): node is JsxFragment;
5160    function isJsxOpeningFragment(node: Node): node is JsxOpeningFragment;
5161    function isJsxClosingFragment(node: Node): node is JsxClosingFragment;
5162    function isJsxAttribute(node: Node): node is JsxAttribute;
5163    function isJsxAttributes(node: Node): node is JsxAttributes;
5164    function isJsxSpreadAttribute(node: Node): node is JsxSpreadAttribute;
5165    function isJsxExpression(node: Node): node is JsxExpression;
5166    function isCaseClause(node: Node): node is CaseClause;
5167    function isDefaultClause(node: Node): node is DefaultClause;
5168    function isHeritageClause(node: Node): node is HeritageClause;
5169    function isCatchClause(node: Node): node is CatchClause;
5170    function isPropertyAssignment(node: Node): node is PropertyAssignment;
5171    function isShorthandPropertyAssignment(node: Node): node is ShorthandPropertyAssignment;
5172    function isSpreadAssignment(node: Node): node is SpreadAssignment;
5173    function isEnumMember(node: Node): node is EnumMember;
5174    function isUnparsedPrepend(node: Node): node is UnparsedPrepend;
5175    function isSourceFile(node: Node): node is SourceFile;
5176    function isBundle(node: Node): node is Bundle;
5177    function isUnparsedSource(node: Node): node is UnparsedSource;
5178    function isJSDocTypeExpression(node: Node): node is JSDocTypeExpression;
5179    function isJSDocNameReference(node: Node): node is JSDocNameReference;
5180    function isJSDocMemberName(node: Node): node is JSDocMemberName;
5181    function isJSDocLink(node: Node): node is JSDocLink;
5182    function isJSDocLinkCode(node: Node): node is JSDocLinkCode;
5183    function isJSDocLinkPlain(node: Node): node is JSDocLinkPlain;
5184    function isJSDocAllType(node: Node): node is JSDocAllType;
5185    function isJSDocUnknownType(node: Node): node is JSDocUnknownType;
5186    function isJSDocNullableType(node: Node): node is JSDocNullableType;
5187    function isJSDocNonNullableType(node: Node): node is JSDocNonNullableType;
5188    function isJSDocOptionalType(node: Node): node is JSDocOptionalType;
5189    function isJSDocFunctionType(node: Node): node is JSDocFunctionType;
5190    function isJSDocVariadicType(node: Node): node is JSDocVariadicType;
5191    function isJSDocNamepathType(node: Node): node is JSDocNamepathType;
5192    function isJSDoc(node: Node): node is JSDoc;
5193    function isJSDocTypeLiteral(node: Node): node is JSDocTypeLiteral;
5194    function isJSDocSignature(node: Node): node is JSDocSignature;
5195    function isJSDocAugmentsTag(node: Node): node is JSDocAugmentsTag;
5196    function isJSDocAuthorTag(node: Node): node is JSDocAuthorTag;
5197    function isJSDocClassTag(node: Node): node is JSDocClassTag;
5198    function isJSDocCallbackTag(node: Node): node is JSDocCallbackTag;
5199    function isJSDocPublicTag(node: Node): node is JSDocPublicTag;
5200    function isJSDocPrivateTag(node: Node): node is JSDocPrivateTag;
5201    function isJSDocProtectedTag(node: Node): node is JSDocProtectedTag;
5202    function isJSDocReadonlyTag(node: Node): node is JSDocReadonlyTag;
5203    function isJSDocOverrideTag(node: Node): node is JSDocOverrideTag;
5204    function isJSDocDeprecatedTag(node: Node): node is JSDocDeprecatedTag;
5205    function isJSDocSeeTag(node: Node): node is JSDocSeeTag;
5206    function isJSDocEnumTag(node: Node): node is JSDocEnumTag;
5207    function isJSDocParameterTag(node: Node): node is JSDocParameterTag;
5208    function isJSDocReturnTag(node: Node): node is JSDocReturnTag;
5209    function isJSDocThisTag(node: Node): node is JSDocThisTag;
5210    function isJSDocTypeTag(node: Node): node is JSDocTypeTag;
5211    function isJSDocTemplateTag(node: Node): node is JSDocTemplateTag;
5212    function isJSDocTypedefTag(node: Node): node is JSDocTypedefTag;
5213    function isJSDocUnknownTag(node: Node): node is JSDocUnknownTag;
5214    function isJSDocPropertyTag(node: Node): node is JSDocPropertyTag;
5215    function isJSDocImplementsTag(node: Node): node is JSDocImplementsTag;
5216}
5217declare namespace ts {
5218    function setTextRange<T extends TextRange>(range: T, location: TextRange | undefined): T;
5219    function canHaveModifiers(node: Node): node is HasModifiers;
5220    function canHaveDecorators(node: Node): node is HasDecorators;
5221}
5222declare namespace ts {
5223    /**
5224     * Invokes a callback for each child of the given node. The 'cbNode' callback is invoked for all child nodes
5225     * stored in properties. If a 'cbNodes' callback is specified, it is invoked for embedded arrays; otherwise,
5226     * embedded arrays are flattened and the 'cbNode' callback is invoked for each element. If a callback returns
5227     * a truthy value, iteration stops and that value is returned. Otherwise, undefined is returned.
5228     *
5229     * @param node a given node to visit its children
5230     * @param cbNode a callback to be invoked for all child nodes
5231     * @param cbNodes a callback to be invoked for embedded array
5232     *
5233     * @remarks `forEachChild` must visit the children of a node in the order
5234     * that they appear in the source code. The language service depends on this property to locate nodes by position.
5235     */
5236    export function forEachChild<T>(node: Node, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined;
5237    export interface CreateSourceFileOptions {
5238        languageVersion: ScriptTarget;
5239        /**
5240         * Controls the format the file is detected as - this can be derived from only the path
5241         * and files on disk, but needs to be done with a module resolution cache in scope to be performant.
5242         * This is usually `undefined` for compilations that do not have `moduleResolution` values of `node16` or `nodenext`.
5243         */
5244        impliedNodeFormat?: ModuleKind.ESNext | ModuleKind.CommonJS;
5245        /**
5246         * Controls how module-y-ness is set for the given file. Usually the result of calling
5247         * `getSetExternalModuleIndicator` on a valid `CompilerOptions` object. If not present, the default
5248         * check specified by `isFileProbablyExternalModule` will be used to set the field.
5249         */
5250        setExternalModuleIndicator?: (file: SourceFile) => void;
5251    }
5252    export function createSourceFile(fileName: string, sourceText: string, languageVersionOrOptions: ScriptTarget | CreateSourceFileOptions, setParentNodes?: boolean, scriptKind?: ScriptKind, options?: CompilerOptions): SourceFile;
5253    export function parseIsolatedEntityName(text: string, languageVersion: ScriptTarget): EntityName | undefined;
5254    /**
5255     * Parse json text into SyntaxTree and return node and parse errors if any
5256     * @param fileName
5257     * @param sourceText
5258     */
5259    export function parseJsonText(fileName: string, sourceText: string): JsonSourceFile;
5260    export function isExternalModule(file: SourceFile): boolean;
5261    export function updateSourceFile(sourceFile: SourceFile, newText: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean, option?: CompilerOptions): SourceFile;
5262    export {};
5263}
5264declare namespace ts {
5265    export function parseCommandLine(commandLine: readonly string[], readFile?: (path: string) => string | undefined): ParsedCommandLine;
5266    export type DiagnosticReporter = (diagnostic: Diagnostic) => void;
5267    /**
5268     * Reports config file diagnostics
5269     */
5270    export interface ConfigFileDiagnosticsReporter {
5271        /**
5272         * Reports unrecoverable error when parsing config file
5273         */
5274        onUnRecoverableConfigFileDiagnostic: DiagnosticReporter;
5275    }
5276    /**
5277     * Interface extending ParseConfigHost to support ParseConfigFile that reads config file and reports errors
5278     */
5279    export interface ParseConfigFileHost extends ParseConfigHost, ConfigFileDiagnosticsReporter {
5280        getCurrentDirectory(): string;
5281    }
5282    /**
5283     * Reads the config file, reports errors if any and exits if the config file cannot be found
5284     */
5285    export function getParsedCommandLineOfConfigFile(configFileName: string, optionsToExtend: CompilerOptions | undefined, host: ParseConfigFileHost, extendedConfigCache?: Map<ExtendedConfigCacheEntry>, watchOptionsToExtend?: WatchOptions, extraFileExtensions?: readonly FileExtensionInfo[]): ParsedCommandLine | undefined;
5286    /**
5287     * Read tsconfig.json file
5288     * @param fileName The path to the config file
5289     */
5290    export function readConfigFile(fileName: string, readFile: (path: string) => string | undefined): {
5291        config?: any;
5292        error?: Diagnostic;
5293    };
5294    /**
5295     * Parse the text of the tsconfig.json file
5296     * @param fileName The path to the config file
5297     * @param jsonText The text of the config file
5298     */
5299    export function parseConfigFileTextToJson(fileName: string, jsonText: string): {
5300        config?: any;
5301        error?: Diagnostic;
5302    };
5303    /**
5304     * Read tsconfig.json file
5305     * @param fileName The path to the config file
5306     */
5307    export function readJsonConfigFile(fileName: string, readFile: (path: string) => string | undefined): TsConfigSourceFile;
5308    /**
5309     * Convert the json syntax tree into the json value
5310     */
5311    export function convertToObject(sourceFile: JsonSourceFile, errors: Push<Diagnostic>): any;
5312    /**
5313     * Parse the contents of a config file (tsconfig.json).
5314     * @param json The contents of the config file to parse
5315     * @param host Instance of ParseConfigHost used to enumerate files in folder.
5316     * @param basePath A root directory to resolve relative path entries in the config
5317     *    file to. e.g. outDir
5318     */
5319    export function parseJsonConfigFileContent(json: any, host: ParseConfigHost, basePath: string, existingOptions?: CompilerOptions, configFileName?: string, resolutionStack?: Path[], extraFileExtensions?: readonly FileExtensionInfo[], extendedConfigCache?: Map<ExtendedConfigCacheEntry>, existingWatchOptions?: WatchOptions): ParsedCommandLine;
5320    /**
5321     * Parse the contents of a config file (tsconfig.json).
5322     * @param jsonNode The contents of the config file to parse
5323     * @param host Instance of ParseConfigHost used to enumerate files in folder.
5324     * @param basePath A root directory to resolve relative path entries in the config
5325     *    file to. e.g. outDir
5326     */
5327    export function parseJsonSourceFileConfigFileContent(sourceFile: TsConfigSourceFile, host: ParseConfigHost, basePath: string, existingOptions?: CompilerOptions, configFileName?: string, resolutionStack?: Path[], extraFileExtensions?: readonly FileExtensionInfo[], extendedConfigCache?: Map<ExtendedConfigCacheEntry>, existingWatchOptions?: WatchOptions): ParsedCommandLine;
5328    export interface ParsedTsconfig {
5329        raw: any;
5330        options?: CompilerOptions;
5331        watchOptions?: WatchOptions;
5332        typeAcquisition?: TypeAcquisition;
5333        /**
5334         * Note that the case of the config path has not yet been normalized, as no files have been imported into the project yet
5335         */
5336        extendedConfigPath?: string;
5337    }
5338    export interface ExtendedConfigCacheEntry {
5339        extendedResult: TsConfigSourceFile;
5340        extendedConfig: ParsedTsconfig | undefined;
5341    }
5342    export function convertCompilerOptionsFromJson(jsonOptions: any, basePath: string, configFileName?: string): {
5343        options: CompilerOptions;
5344        errors: Diagnostic[];
5345    };
5346    export function convertTypeAcquisitionFromJson(jsonOptions: any, basePath: string, configFileName?: string): {
5347        options: TypeAcquisition;
5348        errors: Diagnostic[];
5349    };
5350    export {};
5351}
5352declare namespace ts {
5353    export function getEffectiveTypeRoots(options: CompilerOptions, host: GetEffectiveTypeRootsHost): string[] | undefined;
5354    /**
5355     * @param {string | undefined} containingFile - file that contains type reference directive, can be undefined if containing file is unknown.
5356     * This is possible in case if resolution is performed for directives specified via 'types' parameter. In this case initial path for secondary lookups
5357     * is assumed to be the same as root directory of the project.
5358     */
5359    export function resolveTypeReferenceDirective(typeReferenceDirectiveName: string, containingFile: string | undefined, options: CompilerOptions, host: ModuleResolutionHost, redirectedReference?: ResolvedProjectReference, cache?: TypeReferenceDirectiveResolutionCache, resolutionMode?: SourceFile["impliedNodeFormat"]): ResolvedTypeReferenceDirectiveWithFailedLookupLocations;
5360    /**
5361     * Given a set of options, returns the set of type directive names
5362     *   that should be included for this program automatically.
5363     * This list could either come from the config file,
5364     *   or from enumerating the types root + initial secondary types lookup location.
5365     * More type directives might appear in the program later as a result of loading actual source files;
5366     *   this list is only the set of defaults that are implicitly included.
5367     */
5368    export function getAutomaticTypeDirectiveNames(options: CompilerOptions, host: ModuleResolutionHost): string[];
5369    export interface TypeReferenceDirectiveResolutionCache extends PerDirectoryResolutionCache<ResolvedTypeReferenceDirectiveWithFailedLookupLocations>, PackageJsonInfoCache {
5370    }
5371    export interface ModeAwareCache<T> {
5372        get(key: string, mode: ModuleKind.CommonJS | ModuleKind.ESNext | undefined): T | undefined;
5373        set(key: string, mode: ModuleKind.CommonJS | ModuleKind.ESNext | undefined, value: T): this;
5374        delete(key: string, mode: ModuleKind.CommonJS | ModuleKind.ESNext | undefined): this;
5375        has(key: string, mode: ModuleKind.CommonJS | ModuleKind.ESNext | undefined): boolean;
5376        forEach(cb: (elem: T, key: string, mode: ModuleKind.CommonJS | ModuleKind.ESNext | undefined) => void): void;
5377        size(): number;
5378    }
5379    /**
5380     * Cached resolutions per containing directory.
5381     * This assumes that any module id will have the same resolution for sibling files located in the same folder.
5382     */
5383    export interface PerDirectoryResolutionCache<T> {
5384        getOrCreateCacheForDirectory(directoryName: string, redirectedReference?: ResolvedProjectReference): ModeAwareCache<T>;
5385        clear(): void;
5386        /**
5387         *  Updates with the current compilerOptions the cache will operate with.
5388         *  This updates the redirects map as well if needed so module resolutions are cached if they can across the projects
5389         */
5390        update(options: CompilerOptions): void;
5391    }
5392    export interface ModuleResolutionCache extends PerDirectoryResolutionCache<ResolvedModuleWithFailedLookupLocations>, NonRelativeModuleNameResolutionCache, PackageJsonInfoCache {
5393        getPackageJsonInfoCache(): PackageJsonInfoCache;
5394    }
5395    /**
5396     * Stored map from non-relative module name to a table: directory -> result of module lookup in this directory
5397     * We support only non-relative module names because resolution of relative module names is usually more deterministic and thus less expensive.
5398     */
5399    export interface NonRelativeModuleNameResolutionCache extends PackageJsonInfoCache {
5400        getOrCreateCacheForModuleName(nonRelativeModuleName: string, mode: ModuleKind.CommonJS | ModuleKind.ESNext | undefined, redirectedReference?: ResolvedProjectReference): PerModuleNameCache;
5401    }
5402    export interface PackageJsonInfoCache {
5403        clear(): void;
5404    }
5405    export interface PerModuleNameCache {
5406        get(directory: string): ResolvedModuleWithFailedLookupLocations | undefined;
5407        set(directory: string, result: ResolvedModuleWithFailedLookupLocations): void;
5408    }
5409    export function createModuleResolutionCache(currentDirectory: string, getCanonicalFileName: (s: string) => string, options?: CompilerOptions): ModuleResolutionCache;
5410    export function createTypeReferenceDirectiveResolutionCache(currentDirectory: string, getCanonicalFileName: (s: string) => string, options?: CompilerOptions, packageJsonInfoCache?: PackageJsonInfoCache): TypeReferenceDirectiveResolutionCache;
5411    export function resolveModuleNameFromCache(moduleName: string, containingFile: string, cache: ModuleResolutionCache, mode?: ModuleKind.CommonJS | ModuleKind.ESNext): ResolvedModuleWithFailedLookupLocations | undefined;
5412    export function resolveModuleName(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache, redirectedReference?: ResolvedProjectReference, resolutionMode?: ModuleKind.CommonJS | ModuleKind.ESNext): ResolvedModuleWithFailedLookupLocations;
5413    export function nodeModuleNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache, redirectedReference?: ResolvedProjectReference): ResolvedModuleWithFailedLookupLocations;
5414    /**
5415     * This will be called on the successfully resolved path from `loadModuleFromFile`.
5416     * (Not needed for `loadModuleFromNodeModules` as that looks up the `package.json` or `oh-package.json5` as part of resolution.)
5417     *
5418     * packageDirectory is the directory of the package itself.
5419     *   For `blah/node_modules/foo/index.d.ts` this is packageDirectory: "foo"
5420     *   For `/node_modules/foo/bar.d.ts` this is packageDirectory: "foo"
5421     *   For `/node_modules/@types/foo/bar/index.d.ts` this is packageDirectory: "@types/foo"
5422     *   For `/node_modules/foo/bar/index.d.ts` this is packageDirectory: "foo"
5423     */
5424    export function parseModuleFromPath(resolved: string, packageManagerType?: string): string | undefined;
5425    export function classicNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: NonRelativeModuleNameResolutionCache, redirectedReference?: ResolvedProjectReference): ResolvedModuleWithFailedLookupLocations;
5426    export {};
5427}
5428declare namespace ts {
5429    function concatenateDecoratorsAndModifiers(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined): readonly ModifierLike[] | undefined;
5430    function isEtsFunctionDecorators(name: string | undefined, options: CompilerOptions): boolean;
5431    function isOhpm(packageManagerType: string | undefined): boolean;
5432    const ohModulesPathPart: string;
5433    function isOHModules(modulePath: string): boolean;
5434    function isOhpmAndOhModules(packageManagerType: string | undefined, modulePath: string): boolean;
5435    function getModulePathPartByPMType(packageManagerType: string | undefined): string;
5436    function getModuleByPMType(packageManagerType: string | undefined): string;
5437    function getPackageJsonByPMType(packageManagerType: string | undefined): string;
5438    function isOHModulesDirectory(dirPath: Path): boolean;
5439    function isTargetModulesDerectory(dirPath: Path): boolean;
5440    function pathContainsOHModules(path: string): boolean;
5441    function choosePathContainsModules(packageManagerType: string | undefined, fileName: string): boolean;
5442    function getTypeExportImportAndConstEnumTransformer(context: TransformationContext): (node: SourceFile) => SourceFile;
5443    /**
5444     * Add 'type' flag to import/export when import/export an type member.
5445     * Replace const enum with number and string literal.
5446     */
5447    function transformTypeExportImportAndConstEnumInTypeScript(context: TransformationContext): (node: SourceFile) => SourceFile;
5448    function hasTsNoCheckOrTsIgnoreFlag(node: SourceFile): boolean;
5449    function createObfTextSingleLineWriter(): EmitTextWriter;
5450}
5451declare namespace ts {
5452    /**
5453     * Visits a Node using the supplied visitor, possibly returning a new Node in its place.
5454     *
5455     * @param node The Node to visit.
5456     * @param visitor The callback used to visit the Node.
5457     * @param test A callback to execute to verify the Node is valid.
5458     * @param lift An optional callback to execute to lift a NodeArray into a valid Node.
5459     */
5460    function visitNode<T extends Node>(node: T, visitor: Visitor | undefined, test?: (node: Node) => boolean, lift?: (node: readonly Node[]) => T): T;
5461    /**
5462     * Visits a Node using the supplied visitor, possibly returning a new Node in its place.
5463     *
5464     * @param node The Node to visit.
5465     * @param visitor The callback used to visit the Node.
5466     * @param test A callback to execute to verify the Node is valid.
5467     * @param lift An optional callback to execute to lift a NodeArray into a valid Node.
5468     */
5469    function visitNode<T extends Node>(node: T | undefined, visitor: Visitor | undefined, test?: (node: Node) => boolean, lift?: (node: readonly Node[]) => T): T | undefined;
5470    /**
5471     * Visits a NodeArray using the supplied visitor, possibly returning a new NodeArray in its place.
5472     *
5473     * @param nodes The NodeArray to visit.
5474     * @param visitor The callback used to visit a Node.
5475     * @param test A node test to execute for each node.
5476     * @param start An optional value indicating the starting offset at which to start visiting.
5477     * @param count An optional value indicating the maximum number of nodes to visit.
5478     */
5479    function visitNodes<T extends Node>(nodes: NodeArray<T>, visitor: Visitor | undefined, test?: (node: Node) => boolean, start?: number, count?: number): NodeArray<T>;
5480    /**
5481     * Visits a NodeArray using the supplied visitor, possibly returning a new NodeArray in its place.
5482     *
5483     * @param nodes The NodeArray to visit.
5484     * @param visitor The callback used to visit a Node.
5485     * @param test A node test to execute for each node.
5486     * @param start An optional value indicating the starting offset at which to start visiting.
5487     * @param count An optional value indicating the maximum number of nodes to visit.
5488     */
5489    function visitNodes<T extends Node>(nodes: NodeArray<T> | undefined, visitor: Visitor | undefined, test?: (node: Node) => boolean, start?: number, count?: number): NodeArray<T> | undefined;
5490    /**
5491     * Starts a new lexical environment and visits a statement list, ending the lexical environment
5492     * and merging hoisted declarations upon completion.
5493     */
5494    function visitLexicalEnvironment(statements: NodeArray<Statement>, visitor: Visitor, context: TransformationContext, start?: number, ensureUseStrict?: boolean, nodesVisitor?: NodesVisitor): NodeArray<Statement>;
5495    /**
5496     * Starts a new lexical environment and visits a parameter list, suspending the lexical
5497     * environment upon completion.
5498     */
5499    function visitParameterList(nodes: NodeArray<ParameterDeclaration>, visitor: Visitor, context: TransformationContext, nodesVisitor?: NodesVisitor): NodeArray<ParameterDeclaration>;
5500    function visitParameterList(nodes: NodeArray<ParameterDeclaration> | undefined, visitor: Visitor, context: TransformationContext, nodesVisitor?: NodesVisitor): NodeArray<ParameterDeclaration> | undefined;
5501    /**
5502     * Resumes a suspended lexical environment and visits a function body, ending the lexical
5503     * environment and merging hoisted declarations upon completion.
5504     */
5505    function visitFunctionBody(node: FunctionBody, visitor: Visitor, context: TransformationContext): FunctionBody;
5506    /**
5507     * Resumes a suspended lexical environment and visits a function body, ending the lexical
5508     * environment and merging hoisted declarations upon completion.
5509     */
5510    function visitFunctionBody(node: FunctionBody | undefined, visitor: Visitor, context: TransformationContext): FunctionBody | undefined;
5511    /**
5512     * Resumes a suspended lexical environment and visits a concise body, ending the lexical
5513     * environment and merging hoisted declarations upon completion.
5514     */
5515    function visitFunctionBody(node: ConciseBody, visitor: Visitor, context: TransformationContext): ConciseBody;
5516    /**
5517     * Visits an iteration body, adding any block-scoped variables required by the transformation.
5518     */
5519    function visitIterationBody(body: Statement, visitor: Visitor, context: TransformationContext): Statement;
5520    /**
5521     * Visits each child of a Node using the supplied visitor, possibly returning a new Node of the same kind in its place.
5522     *
5523     * @param node The Node whose children will be visited.
5524     * @param visitor The callback used to visit each child.
5525     * @param context A lexical environment context for the visitor.
5526     */
5527    function visitEachChild<T extends Node>(node: T, visitor: Visitor, context: TransformationContext): T;
5528    /**
5529     * Visits each child of a Node using the supplied visitor, possibly returning a new Node of the same kind in its place.
5530     *
5531     * @param node The Node whose children will be visited.
5532     * @param visitor The callback used to visit each child.
5533     * @param context A lexical environment context for the visitor.
5534     */
5535    function visitEachChild<T extends Node>(node: T | undefined, visitor: Visitor, context: TransformationContext, nodesVisitor?: typeof visitNodes, tokenVisitor?: Visitor): T | undefined;
5536}
5537declare namespace ts {
5538    interface SourceMapGeneratorOptions {
5539        extendedDiagnostics?: boolean;
5540    }
5541    function createSourceMapGenerator(host: EmitHost, file: string, sourceRoot: string, sourcesDirectoryPath: string, generatorOptions: SourceMapGeneratorOptions): SourceMapGenerator;
5542}
5543declare namespace ts {
5544    function getTsBuildInfoEmitOutputFilePath(options: CompilerOptions): string | undefined;
5545    function getTsBuildInfoEmitOutputFilePathForLinter(tsBuildInfoPath: string): string;
5546    function getOutputFileNames(commandLine: ParsedCommandLine, inputFileName: string, ignoreCase: boolean): readonly string[];
5547    function createPrinter(printerOptions?: PrinterOptions, handlers?: PrintHandlers): Printer;
5548}
5549declare namespace ts {
5550    export function findConfigFile(searchPath: string, fileExists: (fileName: string) => boolean, configName?: string): string | undefined;
5551    export function resolveTripleslashReference(moduleName: string, containingFile: string): string;
5552    export function createCompilerHost(options: CompilerOptions, setParentNodes?: boolean): CompilerHost;
5553    export function getPreEmitDiagnostics(program: Program, sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly Diagnostic[];
5554    export interface FormatDiagnosticsHost {
5555        getCurrentDirectory(): string;
5556        getCanonicalFileName(fileName: string): string;
5557        getNewLine(): string;
5558    }
5559    export function formatDiagnostics(diagnostics: readonly Diagnostic[], host: FormatDiagnosticsHost): string;
5560    export function formatDiagnostic(diagnostic: Diagnostic, host: FormatDiagnosticsHost): string;
5561    export function formatDiagnosticsWithColorAndContext(diagnostics: readonly Diagnostic[], host: FormatDiagnosticsHost): string;
5562    export function flattenDiagnosticMessageText(diag: string | DiagnosticMessageChain | undefined, newLine: string, indent?: number): string;
5563    /**
5564     * Calculates the resulting resolution mode for some reference in some file - this is generally the explicitly
5565     * provided resolution mode in the reference, unless one is not present, in which case it is the mode of the containing file.
5566     */
5567    export function getModeForFileReference(ref: FileReference | string, containingFileMode: SourceFile["impliedNodeFormat"]): ModuleKind.CommonJS | ModuleKind.ESNext | undefined;
5568    /**
5569     * Calculates the final resolution mode for an import at some index within a file's imports list. This is generally the explicitly
5570     * 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).
5571     * If you have an actual import node, prefer using getModeForUsageLocation on the reference string node.
5572     * @param file File to fetch the resolution mode within
5573     * @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
5574     */
5575    export function getModeForResolutionAtIndex(file: SourceFile, index: number): ModuleKind.CommonJS | ModuleKind.ESNext | undefined;
5576    /**
5577     * Calculates the final resolution mode for a given module reference node. This is generally the explicitly provided resolution mode, if
5578     * one exists, or the mode of the containing source file. (Excepting import=require, which is always commonjs, and dynamic import, which is always esm).
5579     * Notably, this function always returns `undefined` if the containing file has an `undefined` `impliedNodeFormat` - this field is only set when
5580     * `moduleResolution` is `node16`+.
5581     * @param file The file the import or import-like reference is contained within
5582     * @param usage The module reference string
5583     * @returns The final resolution mode of the import
5584     */
5585    export function getModeForUsageLocation(file: {
5586        impliedNodeFormat?: SourceFile["impliedNodeFormat"];
5587    }, usage: StringLiteralLike): ModuleKind.CommonJS | ModuleKind.ESNext | undefined;
5588    export function getConfigFileParsingDiagnostics(configFileParseResult: ParsedCommandLine): readonly Diagnostic[];
5589    /**
5590     * A function for determining if a given file is esm or cjs format, assuming modern node module resolution rules, as configured by the
5591     * `options` parameter.
5592     *
5593     * @param fileName The normalized absolute path to check the format of (it need not exist on disk)
5594     * @param [packageJsonInfoCache] A cache for package file lookups - it's best to have a cache when this function is called often
5595     * @param host The ModuleResolutionHost which can perform the filesystem lookups for package json data
5596     * @param options The compiler options to perform the analysis under - relevant options are `moduleResolution` and `traceResolution`
5597     * @returns `undefined` if the path has no relevant implied format, `ModuleKind.ESNext` for esm format, and `ModuleKind.CommonJS` for cjs format
5598     */
5599    export function getImpliedNodeFormatForFile(fileName: Path, packageJsonInfoCache: PackageJsonInfoCache | undefined, host: ModuleResolutionHost, options: CompilerOptions): ModuleKind.ESNext | ModuleKind.CommonJS | undefined;
5600    /**
5601     * Create a new 'Program' instance. A Program is an immutable collection of 'SourceFile's and a 'CompilerOptions'
5602     * that represent a compilation unit.
5603     *
5604     * Creating a program proceeds from a set of root files, expanding the set of inputs by following imports and
5605     * triple-slash-reference-path directives transitively. '@types' and triple-slash-reference-types are also pulled in.
5606     *
5607     * @param createProgramOptions - The options for creating a program.
5608     * @returns A 'Program' object.
5609     */
5610    export function createProgram(createProgramOptions: CreateProgramOptions): Program;
5611    /**
5612     * Create a new 'Program' instance. A Program is an immutable collection of 'SourceFile's and a 'CompilerOptions'
5613     * that represent a compilation unit.
5614     *
5615     * Creating a program proceeds from a set of root files, expanding the set of inputs by following imports and
5616     * triple-slash-reference-path directives transitively. '@types' and triple-slash-reference-types are also pulled in.
5617     *
5618     * @param rootNames - A set of root files.
5619     * @param options - The compiler options which should be used.
5620     * @param host - The host interacts with the underlying file system.
5621     * @param oldProgram - Reuses an old program structure.
5622     * @param configFileParsingDiagnostics - error during config file parsing
5623     * @returns A 'Program' object.
5624     */
5625    export function createProgram(rootNames: readonly string[], options: CompilerOptions, host?: CompilerHost, oldProgram?: Program, configFileParsingDiagnostics?: readonly Diagnostic[]): Program;
5626    /** @deprecated */ export interface ResolveProjectReferencePathHost {
5627        fileExists(fileName: string): boolean;
5628    }
5629    /**
5630     * Returns the target config filename of a project reference.
5631     * Note: The file might not exist.
5632     */
5633    export function resolveProjectReferencePath(ref: ProjectReference): ResolvedConfigFileName;
5634    /** @deprecated */ export function resolveProjectReferencePath(host: ResolveProjectReferencePathHost, ref: ProjectReference): ResolvedConfigFileName;
5635    export {};
5636}
5637declare namespace ts {
5638    interface EmitOutput {
5639        outputFiles: OutputFile[];
5640        emitSkipped: boolean;
5641    }
5642    interface OutputFile {
5643        name: string;
5644        writeByteOrderMark: boolean;
5645        text: string;
5646    }
5647}
5648declare namespace ts {
5649    type AffectedFileResult<T> = {
5650        result: T;
5651        affected: SourceFile | Program;
5652    } | undefined;
5653    interface BuilderProgramHost {
5654        /**
5655         * return true if file names are treated with case sensitivity
5656         */
5657        useCaseSensitiveFileNames(): boolean;
5658        /**
5659         * If provided this would be used this hash instead of actual file shape text for detecting changes
5660         */
5661        createHash?: (data: string) => string;
5662        /**
5663         * When emit or emitNextAffectedFile are called without writeFile,
5664         * this callback if present would be used to write files
5665         */
5666        writeFile?: WriteFileCallback;
5667    }
5668    /**
5669     * Builder to manage the program state changes
5670     */
5671    interface BuilderProgram {
5672        /**
5673         * Returns current program
5674         */
5675        getProgram(): Program;
5676        /**
5677         * Get compiler options of the program
5678         */
5679        getCompilerOptions(): CompilerOptions;
5680        /**
5681         * Get the source file in the program with file name
5682         */
5683        getSourceFile(fileName: string): SourceFile | undefined;
5684        /**
5685         * Get a list of files in the program
5686         */
5687        getSourceFiles(): readonly SourceFile[];
5688        /**
5689         * Get the diagnostics for compiler options
5690         */
5691        getOptionsDiagnostics(cancellationToken?: CancellationToken): readonly Diagnostic[];
5692        /**
5693         * Get the diagnostics that dont belong to any file
5694         */
5695        getGlobalDiagnostics(cancellationToken?: CancellationToken): readonly Diagnostic[];
5696        /**
5697         * Get the diagnostics from config file parsing
5698         */
5699        getConfigFileParsingDiagnostics(): readonly Diagnostic[];
5700        /**
5701         * Get the syntax diagnostics, for all source files if source file is not supplied
5702         */
5703        getSyntacticDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly Diagnostic[];
5704        /**
5705         * Get the declaration diagnostics, for all source files if source file is not supplied
5706         */
5707        getDeclarationDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly DiagnosticWithLocation[];
5708        /**
5709         * Get all the dependencies of the file
5710         */
5711        getAllDependencies(sourceFile: SourceFile): readonly string[];
5712        /**
5713         * Gets the semantic diagnostics from the program corresponding to this state of file (if provided) or whole program
5714         * The semantic diagnostics are cached and managed here
5715         * Note that it is assumed that when asked about semantic diagnostics through this API,
5716         * the file has been taken out of affected files so it is safe to use cache or get from program and cache the diagnostics
5717         * In case of SemanticDiagnosticsBuilderProgram if the source file is not provided,
5718         * it will iterate through all the affected files, to ensure that cache stays valid and yet provide a way to get all semantic diagnostics
5719         */
5720        getSemanticDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly Diagnostic[];
5721        /**
5722         * Emits the JavaScript and declaration files.
5723         * When targetSource file is specified, emits the files corresponding to that source file,
5724         * otherwise for the whole program.
5725         * In case of EmitAndSemanticDiagnosticsBuilderProgram, when targetSourceFile is specified,
5726         * it is assumed that that file is handled from affected file list. If targetSourceFile is not specified,
5727         * it will only emit all the affected files instead of whole program
5728         *
5729         * The first of writeFile if provided, writeFile of BuilderProgramHost if provided, writeFile of compiler host
5730         * in that order would be used to write the files
5731         */
5732        emit(targetSourceFile?: SourceFile, writeFile?: WriteFileCallback, cancellationToken?: CancellationToken, emitOnlyDtsFiles?: boolean, customTransformers?: CustomTransformers): EmitResult;
5733        /**
5734         * Get the current directory of the program
5735         */
5736        getCurrentDirectory(): string;
5737        isFileUpdateInConstEnumCache?(sourceFile: SourceFile): boolean;
5738        builderProgramForLinter?: EmitAndSemanticDiagnosticsBuilderProgram;
5739    }
5740    /**
5741     * The builder that caches the semantic diagnostics for the program and handles the changed files and affected files
5742     */
5743    interface SemanticDiagnosticsBuilderProgram extends BuilderProgram {
5744        /**
5745         * Gets the semantic diagnostics from the program for the next affected file and caches it
5746         * Returns undefined if the iteration is complete
5747         */
5748        getSemanticDiagnosticsOfNextAffectedFile(cancellationToken?: CancellationToken, ignoreSourceFile?: (sourceFile: SourceFile) => boolean): AffectedFileResult<readonly Diagnostic[]>;
5749    }
5750    /**
5751     * The builder that can handle the changes in program and iterate through changed file to emit the files
5752     * The semantic diagnostics are cached per file and managed by clearing for the changed/affected files
5753     */
5754    interface EmitAndSemanticDiagnosticsBuilderProgram extends SemanticDiagnosticsBuilderProgram {
5755        /**
5756         * Emits the next affected file's emit result (EmitResult and sourceFiles emitted) or returns undefined if iteration is complete
5757         * The first of writeFile if provided, writeFile of BuilderProgramHost if provided, writeFile of compiler host
5758         * in that order would be used to write the files
5759         */
5760        emitNextAffectedFile(writeFile?: WriteFileCallback, cancellationToken?: CancellationToken, emitOnlyDtsFiles?: boolean, customTransformers?: CustomTransformers): AffectedFileResult<EmitResult>;
5761    }
5762    /**
5763     * Create the builder to manage semantic diagnostics and cache them
5764     */
5765    function createSemanticDiagnosticsBuilderProgram(newProgram: Program, host: BuilderProgramHost, oldProgram?: SemanticDiagnosticsBuilderProgram, configFileParsingDiagnostics?: readonly Diagnostic[]): SemanticDiagnosticsBuilderProgram;
5766    function createSemanticDiagnosticsBuilderProgram(rootNames: readonly string[] | undefined, options: CompilerOptions | undefined, host?: CompilerHost, oldProgram?: SemanticDiagnosticsBuilderProgram, configFileParsingDiagnostics?: readonly Diagnostic[], projectReferences?: readonly ProjectReference[]): SemanticDiagnosticsBuilderProgram;
5767    /**
5768     * Create the builder that can handle the changes in program and iterate through changed files
5769     * to emit the those files and manage semantic diagnostics cache as well
5770     */
5771    function createEmitAndSemanticDiagnosticsBuilderProgram(newProgram: Program, host: BuilderProgramHost, oldProgram?: EmitAndSemanticDiagnosticsBuilderProgram, configFileParsingDiagnostics?: readonly Diagnostic[]): EmitAndSemanticDiagnosticsBuilderProgram;
5772    function createEmitAndSemanticDiagnosticsBuilderProgram(rootNames: readonly string[] | undefined, options: CompilerOptions | undefined, host?: CompilerHost, oldProgram?: EmitAndSemanticDiagnosticsBuilderProgram, configFileParsingDiagnostics?: readonly Diagnostic[], projectReferences?: readonly ProjectReference[]): EmitAndSemanticDiagnosticsBuilderProgram;
5773    function createEmitAndSemanticDiagnosticsBuilderProgramForArkTs(newProgramOrRootNames: Program | readonly string[] | undefined, hostOrOptions: BuilderProgramHost | CompilerOptions | undefined, oldProgramOrHost?: CompilerHost | EmitAndSemanticDiagnosticsBuilderProgram, configFileParsingDiagnosticsOrOldProgram?: readonly Diagnostic[] | EmitAndSemanticDiagnosticsBuilderProgram, configFileParsingDiagnostics?: readonly Diagnostic[], projectReferences?: readonly ProjectReference[]): EmitAndSemanticDiagnosticsBuilderProgram;
5774    /**
5775     * Creates a builder thats just abstraction over program and can be used with watch
5776     */
5777    function createAbstractBuilder(newProgram: Program, host: BuilderProgramHost, oldProgram?: BuilderProgram, configFileParsingDiagnostics?: readonly Diagnostic[]): BuilderProgram;
5778    function createAbstractBuilder(rootNames: readonly string[] | undefined, options: CompilerOptions | undefined, host?: CompilerHost, oldProgram?: BuilderProgram, configFileParsingDiagnostics?: readonly Diagnostic[], projectReferences?: readonly ProjectReference[]): BuilderProgram;
5779}
5780declare namespace ts {
5781    interface ReadBuildProgramHost {
5782        useCaseSensitiveFileNames(): boolean;
5783        getCurrentDirectory(): string;
5784        readFile(fileName: string): string | undefined;
5785        getLastCompiledProgram?(): Program;
5786    }
5787    function readBuilderProgram(compilerOptions: CompilerOptions, host: ReadBuildProgramHost, isForLinter?: boolean): EmitAndSemanticDiagnosticsBuilderProgram | undefined;
5788    function createIncrementalCompilerHost(options: CompilerOptions, system?: System): CompilerHost;
5789    interface IncrementalProgramOptions<T extends BuilderProgram> {
5790        rootNames: readonly string[];
5791        options: CompilerOptions;
5792        configFileParsingDiagnostics?: readonly Diagnostic[];
5793        projectReferences?: readonly ProjectReference[];
5794        host?: CompilerHost;
5795        createProgram?: CreateProgram<T>;
5796    }
5797    function createIncrementalProgram<T extends BuilderProgram = EmitAndSemanticDiagnosticsBuilderProgram>({ rootNames, options, configFileParsingDiagnostics, projectReferences, host, createProgram }: IncrementalProgramOptions<T>): T;
5798    function createIncrementalProgramForArkTs({ rootNames, options, configFileParsingDiagnostics, projectReferences, host }: IncrementalProgramOptions<EmitAndSemanticDiagnosticsBuilderProgram>): EmitAndSemanticDiagnosticsBuilderProgram;
5799    type WatchStatusReporter = (diagnostic: Diagnostic, newLine: string, options: CompilerOptions, errorCount?: number) => void;
5800    /** Create the program with rootNames and options, if they are undefined, oldProgram and new configFile diagnostics create new program */
5801    type CreateProgram<T extends BuilderProgram> = (rootNames: readonly string[] | undefined, options: CompilerOptions | undefined, host?: CompilerHost, oldProgram?: T, configFileParsingDiagnostics?: readonly Diagnostic[], projectReferences?: readonly ProjectReference[] | undefined) => T;
5802    /** Host that has watch functionality used in --watch mode */
5803    interface WatchHost {
5804        /** If provided, called with Diagnostic message that informs about change in watch status */
5805        onWatchStatusChange?(diagnostic: Diagnostic, newLine: string, options: CompilerOptions, errorCount?: number): void;
5806        /** Used to watch changes in source files, missing files needed to update the program or config file */
5807        watchFile(path: string, callback: FileWatcherCallback, pollingInterval?: number, options?: WatchOptions): FileWatcher;
5808        /** Used to watch resolved module's failed lookup locations, config file specs, type roots where auto type reference directives are added */
5809        watchDirectory(path: string, callback: DirectoryWatcherCallback, recursive?: boolean, options?: WatchOptions): FileWatcher;
5810        /** If provided, will be used to set delayed compilation, so that multiple changes in short span are compiled together */
5811        setTimeout?(callback: (...args: any[]) => void, ms: number, ...args: any[]): any;
5812        /** If provided, will be used to reset existing delayed compilation */
5813        clearTimeout?(timeoutId: any): void;
5814    }
5815    interface ProgramHost<T extends BuilderProgram> {
5816        /**
5817         * Used to create the program when need for program creation or recreation detected
5818         */
5819        createProgram: CreateProgram<T>;
5820        useCaseSensitiveFileNames(): boolean;
5821        getNewLine(): string;
5822        getCurrentDirectory(): string;
5823        getDefaultLibFileName(options: CompilerOptions): string;
5824        getDefaultLibLocation?(): string;
5825        createHash?(data: string): string;
5826        /**
5827         * Use to check file presence for source files and
5828         * if resolveModuleNames is not provided (complier is in charge of module resolution) then module files as well
5829         */
5830        fileExists(path: string): boolean;
5831        /**
5832         * Use to read file text for source files and
5833         * if resolveModuleNames is not provided (complier is in charge of module resolution) then module files as well
5834         */
5835        readFile(path: string, encoding?: string): string | undefined;
5836        /** If provided, used for module resolution as well as to handle directory structure */
5837        directoryExists?(path: string): boolean;
5838        /** If provided, used in resolutions as well as handling directory structure */
5839        getDirectories?(path: string): string[];
5840        /** If provided, used to cache and handle directory structure modifications */
5841        readDirectory?(path: string, extensions?: readonly string[], exclude?: readonly string[], include?: readonly string[], depth?: number): string[];
5842        /** Symbol links resolution */
5843        realpath?(path: string): string;
5844        /** If provided would be used to write log about compilation */
5845        trace?(s: string): void;
5846        /** If provided is used to get the environment variable */
5847        getEnvironmentVariable?(name: string): string | undefined;
5848        /** If provided, used to resolve the module names, otherwise typescript's default module resolution */
5849        resolveModuleNames?(moduleNames: string[], containingFile: string, reusedNames: string[] | undefined, redirectedReference: ResolvedProjectReference | undefined, options: CompilerOptions, containingSourceFile?: SourceFile): (ResolvedModule | undefined)[];
5850        /** If provided, used to resolve type reference directives, otherwise typescript's default resolution */
5851        resolveTypeReferenceDirectives?(typeReferenceDirectiveNames: string[] | readonly FileReference[], containingFile: string, redirectedReference: ResolvedProjectReference | undefined, options: CompilerOptions, containingFileMode?: SourceFile["impliedNodeFormat"] | undefined): (ResolvedTypeReferenceDirective | undefined)[];
5852        /** If provided along with custom resolveModuleNames or resolveTypeReferenceDirectives, used to determine if unchanged file path needs to re-resolve modules/type reference directives */
5853        hasInvalidatedResolutions?(filePath: Path): boolean;
5854        /**
5855         * 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
5856         */
5857        getModuleResolutionCache?(): ModuleResolutionCache | undefined;
5858    }
5859    interface WatchCompilerHost<T extends BuilderProgram> extends ProgramHost<T>, WatchHost {
5860        /** Instead of using output d.ts file from project reference, use its source file */
5861        useSourceOfProjectReferenceRedirect?(): boolean;
5862        /** If provided, use this method to get parsed command lines for referenced projects */
5863        getParsedCommandLine?(fileName: string): ParsedCommandLine | undefined;
5864        /** If provided, callback to invoke after every new program creation */
5865        afterProgramCreate?(program: T): void;
5866    }
5867    /**
5868     * Host to create watch with root files and options
5869     */
5870    interface WatchCompilerHostOfFilesAndCompilerOptions<T extends BuilderProgram> extends WatchCompilerHost<T> {
5871        /** root files to use to generate program */
5872        rootFiles: string[];
5873        /** Compiler options */
5874        options: CompilerOptions;
5875        watchOptions?: WatchOptions;
5876        /** Project References */
5877        projectReferences?: readonly ProjectReference[];
5878    }
5879    /**
5880     * Host to create watch with config file
5881     */
5882    interface WatchCompilerHostOfConfigFile<T extends BuilderProgram> extends WatchCompilerHost<T>, ConfigFileDiagnosticsReporter {
5883        /** Name of the config file to compile */
5884        configFileName: string;
5885        /** Options to extend */
5886        optionsToExtend?: CompilerOptions;
5887        watchOptionsToExtend?: WatchOptions;
5888        extraFileExtensions?: readonly FileExtensionInfo[];
5889        /**
5890         * Used to generate source file names from the config file and its include, exclude, files rules
5891         * and also to cache the directory stucture
5892         */
5893        readDirectory(path: string, extensions?: readonly string[], exclude?: readonly string[], include?: readonly string[], depth?: number): string[];
5894    }
5895    interface Watch<T> {
5896        /** Synchronize with host and get updated program */
5897        getProgram(): T;
5898        /** Closes the watch */
5899        close(): void;
5900    }
5901    /**
5902     * Creates the watch what generates program using the config file
5903     */
5904    interface WatchOfConfigFile<T> extends Watch<T> {
5905    }
5906    /**
5907     * Creates the watch that generates program using the root files and compiler options
5908     */
5909    interface WatchOfFilesAndCompilerOptions<T> extends Watch<T> {
5910        /** Updates the root files in the program, only if this is not config file compilation */
5911        updateRootFileNames(fileNames: string[]): void;
5912    }
5913    /**
5914     * Create the watch compiler host for either configFile or fileNames and its options
5915     */
5916    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>;
5917    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>;
5918    /**
5919     * Creates the watch from the host for root files and compiler options
5920     */
5921    function createWatchProgram<T extends BuilderProgram>(host: WatchCompilerHostOfFilesAndCompilerOptions<T>): WatchOfFilesAndCompilerOptions<T>;
5922    /**
5923     * Creates the watch from the host for config file
5924     */
5925    function createWatchProgram<T extends BuilderProgram>(host: WatchCompilerHostOfConfigFile<T>): WatchOfConfigFile<T>;
5926}
5927declare namespace ts {
5928    interface BuildOptions {
5929        dry?: boolean;
5930        force?: boolean;
5931        verbose?: boolean;
5932        incremental?: boolean;
5933        assumeChangesOnlyAffectDirectDependencies?: boolean;
5934        traceResolution?: boolean;
5935        [option: string]: CompilerOptionsValue | undefined;
5936    }
5937    type ReportEmitErrorSummary = (errorCount: number, filesInError: (ReportFileInError | undefined)[]) => void;
5938    interface ReportFileInError {
5939        fileName: string;
5940        line: number;
5941    }
5942    interface SolutionBuilderHostBase<T extends BuilderProgram> extends ProgramHost<T> {
5943        createDirectory?(path: string): void;
5944        /**
5945         * Should provide create directory and writeFile if done of invalidatedProjects is not invoked with
5946         * writeFileCallback
5947         */
5948        writeFile?(path: string, data: string, writeByteOrderMark?: boolean): void;
5949        getCustomTransformers?: (project: string) => CustomTransformers | undefined;
5950        getModifiedTime(fileName: string): Date | undefined;
5951        setModifiedTime(fileName: string, date: Date): void;
5952        deleteFile(fileName: string): void;
5953        getParsedCommandLine?(fileName: string): ParsedCommandLine | undefined;
5954        reportDiagnostic: DiagnosticReporter;
5955        reportSolutionBuilderStatus: DiagnosticReporter;
5956        afterProgramEmitAndDiagnostics?(program: T): void;
5957    }
5958    interface SolutionBuilderHost<T extends BuilderProgram> extends SolutionBuilderHostBase<T> {
5959        reportErrorSummary?: ReportEmitErrorSummary;
5960    }
5961    interface SolutionBuilderWithWatchHost<T extends BuilderProgram> extends SolutionBuilderHostBase<T>, WatchHost {
5962    }
5963    interface SolutionBuilder<T extends BuilderProgram> {
5964        build(project?: string, cancellationToken?: CancellationToken, writeFile?: WriteFileCallback, getCustomTransformers?: (project: string) => CustomTransformers): ExitStatus;
5965        clean(project?: string): ExitStatus;
5966        buildReferences(project: string, cancellationToken?: CancellationToken, writeFile?: WriteFileCallback, getCustomTransformers?: (project: string) => CustomTransformers): ExitStatus;
5967        cleanReferences(project?: string): ExitStatus;
5968        getNextInvalidatedProject(cancellationToken?: CancellationToken): InvalidatedProject<T> | undefined;
5969    }
5970    /**
5971     * Create a function that reports watch status by writing to the system and handles the formating of the diagnostic
5972     */
5973    function createBuilderStatusReporter(system: System, pretty?: boolean): DiagnosticReporter;
5974    function createSolutionBuilderHost<T extends BuilderProgram = EmitAndSemanticDiagnosticsBuilderProgram>(system?: System, createProgram?: CreateProgram<T>, reportDiagnostic?: DiagnosticReporter, reportSolutionBuilderStatus?: DiagnosticReporter, reportErrorSummary?: ReportEmitErrorSummary): SolutionBuilderHost<T>;
5975    function createSolutionBuilderWithWatchHost<T extends BuilderProgram = EmitAndSemanticDiagnosticsBuilderProgram>(system?: System, createProgram?: CreateProgram<T>, reportDiagnostic?: DiagnosticReporter, reportSolutionBuilderStatus?: DiagnosticReporter, reportWatchStatus?: WatchStatusReporter): SolutionBuilderWithWatchHost<T>;
5976    function createSolutionBuilder<T extends BuilderProgram>(host: SolutionBuilderHost<T>, rootNames: readonly string[], defaultOptions: BuildOptions): SolutionBuilder<T>;
5977    function createSolutionBuilderWithWatch<T extends BuilderProgram>(host: SolutionBuilderWithWatchHost<T>, rootNames: readonly string[], defaultOptions: BuildOptions, baseWatchOptions?: WatchOptions): SolutionBuilder<T>;
5978    enum InvalidatedProjectKind {
5979        Build = 0,
5980        UpdateBundle = 1,
5981        UpdateOutputFileStamps = 2
5982    }
5983    interface InvalidatedProjectBase {
5984        readonly kind: InvalidatedProjectKind;
5985        readonly project: ResolvedConfigFileName;
5986        /**
5987         *  To dispose this project and ensure that all the necessary actions are taken and state is updated accordingly
5988         */
5989        done(cancellationToken?: CancellationToken, writeFile?: WriteFileCallback, customTransformers?: CustomTransformers): ExitStatus;
5990        getCompilerOptions(): CompilerOptions;
5991        getCurrentDirectory(): string;
5992    }
5993    interface UpdateOutputFileStampsProject extends InvalidatedProjectBase {
5994        readonly kind: InvalidatedProjectKind.UpdateOutputFileStamps;
5995        updateOutputFileStatmps(): void;
5996    }
5997    interface BuildInvalidedProject<T extends BuilderProgram> extends InvalidatedProjectBase {
5998        readonly kind: InvalidatedProjectKind.Build;
5999        getBuilderProgram(): T | undefined;
6000        getProgram(): Program | undefined;
6001        getSourceFile(fileName: string): SourceFile | undefined;
6002        getSourceFiles(): readonly SourceFile[];
6003        getOptionsDiagnostics(cancellationToken?: CancellationToken): readonly Diagnostic[];
6004        getGlobalDiagnostics(cancellationToken?: CancellationToken): readonly Diagnostic[];
6005        getConfigFileParsingDiagnostics(): readonly Diagnostic[];
6006        getSyntacticDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly Diagnostic[];
6007        getAllDependencies(sourceFile: SourceFile): readonly string[];
6008        getSemanticDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly Diagnostic[];
6009        getSemanticDiagnosticsOfNextAffectedFile(cancellationToken?: CancellationToken, ignoreSourceFile?: (sourceFile: SourceFile) => boolean): AffectedFileResult<readonly Diagnostic[]>;
6010        emit(targetSourceFile?: SourceFile, writeFile?: WriteFileCallback, cancellationToken?: CancellationToken, emitOnlyDtsFiles?: boolean, customTransformers?: CustomTransformers): EmitResult | undefined;
6011    }
6012    interface UpdateBundleProject<T extends BuilderProgram> extends InvalidatedProjectBase {
6013        readonly kind: InvalidatedProjectKind.UpdateBundle;
6014        emit(writeFile?: WriteFileCallback, customTransformers?: CustomTransformers): EmitResult | BuildInvalidedProject<T> | undefined;
6015    }
6016    type InvalidatedProject<T extends BuilderProgram> = UpdateOutputFileStampsProject | BuildInvalidedProject<T> | UpdateBundleProject<T>;
6017}
6018declare namespace ts.server {
6019    type ActionSet = "action::set";
6020    type ActionInvalidate = "action::invalidate";
6021    type ActionPackageInstalled = "action::packageInstalled";
6022    type EventTypesRegistry = "event::typesRegistry";
6023    type EventBeginInstallTypes = "event::beginInstallTypes";
6024    type EventEndInstallTypes = "event::endInstallTypes";
6025    type EventInitializationFailed = "event::initializationFailed";
6026}
6027declare namespace ts.server {
6028    interface TypingInstallerResponse {
6029        readonly kind: ActionSet | ActionInvalidate | EventTypesRegistry | ActionPackageInstalled | EventBeginInstallTypes | EventEndInstallTypes | EventInitializationFailed;
6030    }
6031    interface TypingInstallerRequestWithProjectName {
6032        readonly projectName: string;
6033    }
6034    interface DiscoverTypings extends TypingInstallerRequestWithProjectName {
6035        readonly fileNames: string[];
6036        readonly projectRootPath: Path;
6037        readonly compilerOptions: CompilerOptions;
6038        readonly watchOptions?: WatchOptions;
6039        readonly typeAcquisition: TypeAcquisition;
6040        readonly unresolvedImports: SortedReadonlyArray<string>;
6041        readonly cachePath?: string;
6042        readonly kind: "discover";
6043    }
6044    interface CloseProject extends TypingInstallerRequestWithProjectName {
6045        readonly kind: "closeProject";
6046    }
6047    interface TypesRegistryRequest {
6048        readonly kind: "typesRegistry";
6049    }
6050    interface InstallPackageRequest extends TypingInstallerRequestWithProjectName {
6051        readonly kind: "installPackage";
6052        readonly fileName: Path;
6053        readonly packageName: string;
6054        readonly projectRootPath: Path;
6055    }
6056    interface PackageInstalledResponse extends ProjectResponse {
6057        readonly kind: ActionPackageInstalled;
6058        readonly success: boolean;
6059        readonly message: string;
6060    }
6061    interface InitializationFailedResponse extends TypingInstallerResponse {
6062        readonly kind: EventInitializationFailed;
6063        readonly message: string;
6064        readonly stack?: string;
6065    }
6066    interface ProjectResponse extends TypingInstallerResponse {
6067        readonly projectName: string;
6068    }
6069    interface InvalidateCachedTypings extends ProjectResponse {
6070        readonly kind: ActionInvalidate;
6071    }
6072    interface InstallTypes extends ProjectResponse {
6073        readonly kind: EventBeginInstallTypes | EventEndInstallTypes;
6074        readonly eventId: number;
6075        readonly typingsInstallerVersion: string;
6076        readonly packagesToInstall: readonly string[];
6077    }
6078    interface BeginInstallTypes extends InstallTypes {
6079        readonly kind: EventBeginInstallTypes;
6080    }
6081    interface EndInstallTypes extends InstallTypes {
6082        readonly kind: EventEndInstallTypes;
6083        readonly installSuccess: boolean;
6084    }
6085    interface SetTypings extends ProjectResponse {
6086        readonly typeAcquisition: TypeAcquisition;
6087        readonly compilerOptions: CompilerOptions;
6088        readonly typings: string[];
6089        readonly unresolvedImports: SortedReadonlyArray<string>;
6090        readonly kind: ActionSet;
6091    }
6092}
6093declare namespace ts {
6094    interface Node {
6095        getSourceFile(): SourceFile;
6096        getChildCount(sourceFile?: SourceFile): number;
6097        getChildAt(index: number, sourceFile?: SourceFile): Node;
6098        getChildren(sourceFile?: SourceFile): Node[];
6099        getStart(sourceFile?: SourceFile, includeJsDocComment?: boolean): number;
6100        getFullStart(): number;
6101        getEnd(): number;
6102        getWidth(sourceFile?: SourceFileLike): number;
6103        getFullWidth(): number;
6104        getLeadingTriviaWidth(sourceFile?: SourceFile): number;
6105        getFullText(sourceFile?: SourceFile): string;
6106        getText(sourceFile?: SourceFile): string;
6107        getFirstToken(sourceFile?: SourceFile): Node | undefined;
6108        getLastToken(sourceFile?: SourceFile): Node | undefined;
6109        forEachChild<T>(cbNode: (node: Node) => T | undefined, cbNodeArray?: (nodes: NodeArray<Node>) => T | undefined): T | undefined;
6110    }
6111    interface Identifier {
6112        readonly text: string;
6113    }
6114    interface PrivateIdentifier {
6115        readonly text: string;
6116    }
6117    interface Symbol {
6118        readonly name: string;
6119        getFlags(): SymbolFlags;
6120        getEscapedName(): __String;
6121        getName(): string;
6122        getDeclarations(): Declaration[] | undefined;
6123        getDocumentationComment(typeChecker: TypeChecker | undefined): SymbolDisplayPart[];
6124        getJsDocTags(checker?: TypeChecker): JSDocTagInfo[];
6125    }
6126    interface Type {
6127        getFlags(): TypeFlags;
6128        getSymbol(): Symbol | undefined;
6129        getProperties(): Symbol[];
6130        getProperty(propertyName: string): Symbol | undefined;
6131        getApparentProperties(): Symbol[];
6132        getCallSignatures(): readonly Signature[];
6133        getConstructSignatures(): readonly Signature[];
6134        getStringIndexType(): Type | undefined;
6135        getNumberIndexType(): Type | undefined;
6136        getBaseTypes(): BaseType[] | undefined;
6137        getNonNullableType(): Type;
6138        getConstraint(): Type | undefined;
6139        getDefault(): Type | undefined;
6140        isUnion(): this is UnionType;
6141        isIntersection(): this is IntersectionType;
6142        isUnionOrIntersection(): this is UnionOrIntersectionType;
6143        isLiteral(): this is LiteralType;
6144        isStringLiteral(): this is StringLiteralType;
6145        isNumberLiteral(): this is NumberLiteralType;
6146        isTypeParameter(): this is TypeParameter;
6147        isClassOrInterface(): this is InterfaceType;
6148        isClass(): this is InterfaceType;
6149        isIndexType(): this is IndexType;
6150    }
6151    interface TypeReference {
6152        typeArguments?: readonly Type[];
6153    }
6154    interface Signature {
6155        getDeclaration(): SignatureDeclaration;
6156        getTypeParameters(): TypeParameter[] | undefined;
6157        getParameters(): Symbol[];
6158        getTypeParameterAtPosition(pos: number): Type;
6159        getReturnType(): Type;
6160        getDocumentationComment(typeChecker: TypeChecker | undefined): SymbolDisplayPart[];
6161        getJsDocTags(): JSDocTagInfo[];
6162    }
6163    interface SourceFile {
6164        getLineAndCharacterOfPosition(pos: number): LineAndCharacter;
6165        getLineEndOfPosition(pos: number): number;
6166        getLineStarts(): readonly number[];
6167        getPositionOfLineAndCharacter(line: number, character: number): number;
6168        update(newText: string, textChangeRange: TextChangeRange): SourceFile;
6169    }
6170    interface SourceFileLike {
6171        getLineAndCharacterOfPosition(pos: number): LineAndCharacter;
6172    }
6173    interface SourceMapSource {
6174        getLineAndCharacterOfPosition(pos: number): LineAndCharacter;
6175    }
6176    /**
6177     * Represents an immutable snapshot of a script at a specified time.Once acquired, the
6178     * snapshot is observably immutable. i.e. the same calls with the same parameters will return
6179     * the same values.
6180     */
6181    interface IScriptSnapshot {
6182        /** Gets a portion of the script snapshot specified by [start, end). */
6183        getText(start: number, end: number): string;
6184        /** Gets the length of this script snapshot. */
6185        getLength(): number;
6186        /**
6187         * Gets the TextChangeRange that describe how the text changed between this text and
6188         * an older version.  This information is used by the incremental parser to determine
6189         * what sections of the script need to be re-parsed.  'undefined' can be returned if the
6190         * change range cannot be determined.  However, in that case, incremental parsing will
6191         * not happen and the entire document will be re - parsed.
6192         */
6193        getChangeRange(oldSnapshot: IScriptSnapshot): TextChangeRange | undefined;
6194        /** Releases all resources held by this script snapshot */
6195        dispose?(): void;
6196    }
6197    namespace ScriptSnapshot {
6198        function fromString(text: string): IScriptSnapshot;
6199    }
6200    interface PreProcessedFileInfo {
6201        referencedFiles: FileReference[];
6202        typeReferenceDirectives: FileReference[];
6203        libReferenceDirectives: FileReference[];
6204        importedFiles: FileReference[];
6205        ambientExternalModules?: string[];
6206        isLibFile: boolean;
6207    }
6208    interface HostCancellationToken {
6209        isCancellationRequested(): boolean;
6210    }
6211    interface InstallPackageOptions {
6212        fileName: Path;
6213        packageName: string;
6214    }
6215    interface PerformanceEvent {
6216        kind: "UpdateGraph" | "CreatePackageJsonAutoImportProvider";
6217        durationMs: number;
6218    }
6219    enum LanguageServiceMode {
6220        Semantic = 0,
6221        PartialSemantic = 1,
6222        Syntactic = 2
6223    }
6224    interface IncompleteCompletionsCache {
6225        get(): CompletionInfo | undefined;
6226        set(response: CompletionInfo): void;
6227        clear(): void;
6228    }
6229    interface LanguageServiceHost extends GetEffectiveTypeRootsHost, MinimalResolutionCacheHost {
6230        getCompilationSettings(): CompilerOptions;
6231        getNewLine?(): string;
6232        getProjectVersion?(): string;
6233        getScriptFileNames(): string[];
6234        getScriptKind?(fileName: string): ScriptKind;
6235        getScriptVersion(fileName: string): string;
6236        getScriptSnapshot(fileName: string): IScriptSnapshot | undefined;
6237        getProjectReferences?(): readonly ProjectReference[] | undefined;
6238        getLocalizedDiagnosticMessages?(): any;
6239        getCancellationToken?(): HostCancellationToken;
6240        getCurrentDirectory(): string;
6241        getDefaultLibFileName(options: CompilerOptions): string;
6242        log?(s: string): void;
6243        trace?(s: string): void;
6244        error?(s: string): void;
6245        useCaseSensitiveFileNames?(): boolean;
6246        readDirectory?(path: string, extensions?: readonly string[], exclude?: readonly string[], include?: readonly string[], depth?: number): string[];
6247        realpath?(path: string): string;
6248        readFile(path: string, encoding?: string): string | undefined;
6249        fileExists(path: string): boolean;
6250        getTypeRootsVersion?(): number;
6251        resolveModuleNames?(moduleNames: string[], containingFile: string, reusedNames: string[] | undefined, redirectedReference: ResolvedProjectReference | undefined, options: CompilerOptions, containingSourceFile?: SourceFile): (ResolvedModule | undefined)[];
6252        getResolvedModuleWithFailedLookupLocationsFromCache?(modulename: string, containingFile: string, resolutionMode?: ModuleKind.CommonJS | ModuleKind.ESNext): ResolvedModuleWithFailedLookupLocations | undefined;
6253        resolveTypeReferenceDirectives?(typeDirectiveNames: string[] | FileReference[], containingFile: string, redirectedReference: ResolvedProjectReference | undefined, options: CompilerOptions, containingFileMode?: SourceFile["impliedNodeFormat"] | undefined): (ResolvedTypeReferenceDirective | undefined)[];
6254        getDirectories?(directoryName: string): string[];
6255        /**
6256         * Gets a set of custom transformers to use during emit.
6257         */
6258        getCustomTransformers?(): CustomTransformers | undefined;
6259        isKnownTypesPackageName?(name: string): boolean;
6260        installPackage?(options: InstallPackageOptions): Promise<ApplyCodeActionCommandResult>;
6261        writeFile?(fileName: string, content: string): void;
6262        getParsedCommandLine?(fileName: string): ParsedCommandLine | undefined;
6263        getJsDocNodeCheckedConfig?(jsDocFileCheckInfo: FileCheckModuleInfo, symbolSourceFilePath: string): JsDocNodeCheckConfig;
6264        getJsDocNodeConditionCheckedResult?(jsDocFileCheckedInfo: FileCheckModuleInfo, jsDocs: JsDocTagInfo[]): ConditionCheckResult;
6265        getFileCheckedModuleInfo?(containFilePath: string): FileCheckModuleInfo;
6266        shouldCompletionSortCustom?: boolean;
6267        uiProps?: string[];
6268        clearProps?(): void;
6269    }
6270    type WithMetadata<T> = T & {
6271        metadata?: unknown;
6272    };
6273    enum SemanticClassificationFormat {
6274        Original = "original",
6275        TwentyTwenty = "2020"
6276    }
6277    interface LanguageService {
6278        /** This is used as a part of restarting the language service. */
6279        cleanupSemanticCache(): void;
6280        /**
6281         * Gets errors indicating invalid syntax in a file.
6282         *
6283         * In English, "this cdeo have, erorrs" is syntactically invalid because it has typos,
6284         * grammatical errors, and misplaced punctuation. Likewise, examples of syntax
6285         * errors in TypeScript are missing parentheses in an `if` statement, mismatched
6286         * curly braces, and using a reserved keyword as a variable name.
6287         *
6288         * These diagnostics are inexpensive to compute and don't require knowledge of
6289         * other files. Note that a non-empty result increases the likelihood of false positives
6290         * from `getSemanticDiagnostics`.
6291         *
6292         * While these represent the majority of syntax-related diagnostics, there are some
6293         * that require the type system, which will be present in `getSemanticDiagnostics`.
6294         *
6295         * @param fileName A path to the file you want syntactic diagnostics for
6296         */
6297        getSyntacticDiagnostics(fileName: string): DiagnosticWithLocation[];
6298        /**
6299         * Gets warnings or errors indicating type system issues in a given file.
6300         * Requesting semantic diagnostics may start up the type system and
6301         * run deferred work, so the first call may take longer than subsequent calls.
6302         *
6303         * Unlike the other get*Diagnostics functions, these diagnostics can potentially not
6304         * include a reference to a source file. Specifically, the first time this is called,
6305         * it will return global diagnostics with no associated location.
6306         *
6307         * To contrast the differences between semantic and syntactic diagnostics, consider the
6308         * sentence: "The sun is green." is syntactically correct; those are real English words with
6309         * correct sentence structure. However, it is semantically invalid, because it is not true.
6310         *
6311         * @param fileName A path to the file you want semantic diagnostics for
6312         */
6313        getSemanticDiagnostics(fileName: string): Diagnostic[];
6314        /**
6315         * Gets suggestion diagnostics for a specific file. These diagnostics tend to
6316         * proactively suggest refactors, as opposed to diagnostics that indicate
6317         * potentially incorrect runtime behavior.
6318         *
6319         * @param fileName A path to the file you want semantic diagnostics for
6320         */
6321        getSuggestionDiagnostics(fileName: string): DiagnosticWithLocation[];
6322        /**
6323         * Gets global diagnostics related to the program configuration and compiler options.
6324         */
6325        getCompilerOptionsDiagnostics(): Diagnostic[];
6326        /** @deprecated Use getEncodedSyntacticClassifications instead. */
6327        getSyntacticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[];
6328        getSyntacticClassifications(fileName: string, span: TextSpan, format: SemanticClassificationFormat): ClassifiedSpan[] | ClassifiedSpan2020[];
6329        /** @deprecated Use getEncodedSemanticClassifications instead. */
6330        getSemanticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[];
6331        getSemanticClassifications(fileName: string, span: TextSpan, format: SemanticClassificationFormat): ClassifiedSpan[] | ClassifiedSpan2020[];
6332        /** Encoded as triples of [start, length, ClassificationType]. */
6333        getEncodedSyntacticClassifications(fileName: string, span: TextSpan): Classifications;
6334        /**
6335         * Gets semantic highlights information for a particular file. Has two formats, an older
6336         * version used by VS and a format used by VS Code.
6337         *
6338         * @param fileName The path to the file
6339         * @param position A text span to return results within
6340         * @param format Which format to use, defaults to "original"
6341         * @returns a number array encoded as triples of [start, length, ClassificationType, ...].
6342         */
6343        getEncodedSemanticClassifications(fileName: string, span: TextSpan, format?: SemanticClassificationFormat): Classifications;
6344        /**
6345         * Gets completion entries at a particular position in a file.
6346         *
6347         * @param fileName The path to the file
6348         * @param position A zero-based index of the character where you want the entries
6349         * @param options An object describing how the request was triggered and what kinds
6350         * of code actions can be returned with the completions.
6351         * @param formattingSettings settings needed for calling formatting functions.
6352         */
6353        getCompletionsAtPosition(fileName: string, position: number, options: GetCompletionsAtPositionOptions | undefined, formattingSettings?: FormatCodeSettings): WithMetadata<CompletionInfo> | undefined;
6354        /**
6355         * Gets the extended details for a completion entry retrieved from `getCompletionsAtPosition`.
6356         *
6357         * @param fileName The path to the file
6358         * @param position A zero based index of the character where you want the entries
6359         * @param entryName The `name` from an existing completion which came from `getCompletionsAtPosition`
6360         * @param formatOptions How should code samples in the completions be formatted, can be undefined for backwards compatibility
6361         * @param source `source` property from the completion entry
6362         * @param preferences User settings, can be undefined for backwards compatibility
6363         * @param data `data` property from the completion entry
6364         */
6365        getCompletionEntryDetails(fileName: string, position: number, entryName: string, formatOptions: FormatCodeOptions | FormatCodeSettings | undefined, source: string | undefined, preferences: UserPreferences | undefined, data: CompletionEntryData | undefined): CompletionEntryDetails | undefined;
6366        getCompletionEntrySymbol(fileName: string, position: number, name: string, source: string | undefined): Symbol | undefined;
6367        /**
6368         * Gets semantic information about the identifier at a particular position in a
6369         * file. Quick info is what you typically see when you hover in an editor.
6370         *
6371         * @param fileName The path to the file
6372         * @param position A zero-based index of the character where you want the quick info
6373         */
6374        getQuickInfoAtPosition(fileName: string, position: number): QuickInfo | undefined;
6375        getNameOrDottedNameSpan(fileName: string, startPos: number, endPos: number): TextSpan | undefined;
6376        getBreakpointStatementAtPosition(fileName: string, position: number): TextSpan | undefined;
6377        getSignatureHelpItems(fileName: string, position: number, options: SignatureHelpItemsOptions | undefined): SignatureHelpItems | undefined;
6378        getRenameInfo(fileName: string, position: number, preferences: UserPreferences): RenameInfo;
6379        /** @deprecated Use the signature with `UserPreferences` instead. */
6380        getRenameInfo(fileName: string, position: number, options?: RenameInfoOptions): RenameInfo;
6381        findRenameLocations(fileName: string, position: number, findInStrings: boolean, findInComments: boolean, providePrefixAndSuffixTextForRename?: boolean): readonly RenameLocation[] | undefined;
6382        getSmartSelectionRange(fileName: string, position: number): SelectionRange;
6383        getDefinitionAtPosition(fileName: string, position: number): readonly DefinitionInfo[] | undefined;
6384        getDefinitionAndBoundSpan(fileName: string, position: number): DefinitionInfoAndBoundSpan | undefined;
6385        getTypeDefinitionAtPosition(fileName: string, position: number): readonly DefinitionInfo[] | undefined;
6386        getImplementationAtPosition(fileName: string, position: number): readonly ImplementationLocation[] | undefined;
6387        getReferencesAtPosition(fileName: string, position: number): ReferenceEntry[] | undefined;
6388        findReferences(fileName: string, position: number): ReferencedSymbol[] | undefined;
6389        getDocumentHighlights(fileName: string, position: number, filesToSearch: string[]): DocumentHighlights[] | undefined;
6390        getFileReferences(fileName: string): ReferenceEntry[];
6391        /** @deprecated */
6392        getOccurrencesAtPosition(fileName: string, position: number): readonly ReferenceEntry[] | undefined;
6393        getNavigateToItems(searchValue: string, maxResultCount?: number, fileName?: string, excludeDtsFiles?: boolean): NavigateToItem[];
6394        getNavigationBarItems(fileName: string): NavigationBarItem[];
6395        getNavigationTree(fileName: string): NavigationTree;
6396        prepareCallHierarchy(fileName: string, position: number): CallHierarchyItem | CallHierarchyItem[] | undefined;
6397        provideCallHierarchyIncomingCalls(fileName: string, position: number): CallHierarchyIncomingCall[];
6398        provideCallHierarchyOutgoingCalls(fileName: string, position: number): CallHierarchyOutgoingCall[];
6399        provideInlayHints(fileName: string, span: TextSpan, preferences: UserPreferences | undefined): InlayHint[];
6400        getOutliningSpans(fileName: string): OutliningSpan[];
6401        getTodoComments(fileName: string, descriptors: TodoCommentDescriptor[]): TodoComment[];
6402        getBraceMatchingAtPosition(fileName: string, position: number): TextSpan[];
6403        getIndentationAtPosition(fileName: string, position: number, options: EditorOptions | EditorSettings): number;
6404        getFormattingEditsForRange(fileName: string, start: number, end: number, options: FormatCodeOptions | FormatCodeSettings): TextChange[];
6405        getFormattingEditsForDocument(fileName: string, options: FormatCodeOptions | FormatCodeSettings): TextChange[];
6406        getFormattingEditsAfterKeystroke(fileName: string, position: number, key: string, options: FormatCodeOptions | FormatCodeSettings): TextChange[];
6407        getDocCommentTemplateAtPosition(fileName: string, position: number, options?: DocCommentTemplateOptions): TextInsertion | undefined;
6408        isValidBraceCompletionAtPosition(fileName: string, position: number, openingBrace: number): boolean;
6409        /**
6410         * 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.
6411         * Editors should call this after `>` is typed.
6412         */
6413        getJsxClosingTagAtPosition(fileName: string, position: number): JsxClosingTagInfo | undefined;
6414        getSpanOfEnclosingComment(fileName: string, position: number, onlyMultiLine: boolean): TextSpan | undefined;
6415        toLineColumnOffset?(fileName: string, position: number): LineAndCharacter;
6416        getCodeFixesAtPosition(fileName: string, start: number, end: number, errorCodes: readonly number[], formatOptions: FormatCodeSettings, preferences: UserPreferences): readonly CodeFixAction[];
6417        getCombinedCodeFix(scope: CombinedCodeFixScope, fixId: {}, formatOptions: FormatCodeSettings, preferences: UserPreferences): CombinedCodeActions;
6418        applyCodeActionCommand(action: CodeActionCommand, formatSettings?: FormatCodeSettings): Promise<ApplyCodeActionCommandResult>;
6419        applyCodeActionCommand(action: CodeActionCommand[], formatSettings?: FormatCodeSettings): Promise<ApplyCodeActionCommandResult[]>;
6420        applyCodeActionCommand(action: CodeActionCommand | CodeActionCommand[], formatSettings?: FormatCodeSettings): Promise<ApplyCodeActionCommandResult | ApplyCodeActionCommandResult[]>;
6421        /** @deprecated `fileName` will be ignored */
6422        applyCodeActionCommand(fileName: string, action: CodeActionCommand): Promise<ApplyCodeActionCommandResult>;
6423        /** @deprecated `fileName` will be ignored */
6424        applyCodeActionCommand(fileName: string, action: CodeActionCommand[]): Promise<ApplyCodeActionCommandResult[]>;
6425        /** @deprecated `fileName` will be ignored */
6426        applyCodeActionCommand(fileName: string, action: CodeActionCommand | CodeActionCommand[]): Promise<ApplyCodeActionCommandResult | ApplyCodeActionCommandResult[]>;
6427        getApplicableRefactors(fileName: string, positionOrRange: number | TextRange, preferences: UserPreferences | undefined, triggerReason?: RefactorTriggerReason, kind?: string): ApplicableRefactorInfo[];
6428        getEditsForRefactor(fileName: string, formatOptions: FormatCodeSettings, positionOrRange: number | TextRange, refactorName: string, actionName: string, preferences: UserPreferences | undefined): RefactorEditInfo | undefined;
6429        organizeImports(args: OrganizeImportsArgs, formatOptions: FormatCodeSettings, preferences: UserPreferences | undefined): readonly FileTextChanges[];
6430        getEditsForFileRename(oldFilePath: string, newFilePath: string, formatOptions: FormatCodeSettings, preferences: UserPreferences | undefined): readonly FileTextChanges[];
6431        getEmitOutput(fileName: string, emitOnlyDtsFiles?: boolean, forceDtsEmit?: boolean): EmitOutput;
6432        getProgram(): Program | undefined;
6433        getBuilderProgram(): BuilderProgram | undefined;
6434        toggleLineComment(fileName: string, textRange: TextRange): TextChange[];
6435        toggleMultilineComment(fileName: string, textRange: TextRange): TextChange[];
6436        commentSelection(fileName: string, textRange: TextRange): TextChange[];
6437        uncommentSelection(fileName: string, textRange: TextRange): TextChange[];
6438        dispose(): void;
6439        updateRootFiles?(rootFiles: string[]): void;
6440        getProps?(): string[];
6441    }
6442    interface JsxClosingTagInfo {
6443        readonly newText: string;
6444    }
6445    interface CombinedCodeFixScope {
6446        type: "file";
6447        fileName: string;
6448    }
6449    enum OrganizeImportsMode {
6450        All = "All",
6451        SortAndCombine = "SortAndCombine",
6452        RemoveUnused = "RemoveUnused"
6453    }
6454    interface OrganizeImportsArgs extends CombinedCodeFixScope {
6455        /** @deprecated Use `mode` instead */
6456        skipDestructiveCodeActions?: boolean;
6457        mode?: OrganizeImportsMode;
6458    }
6459    type CompletionsTriggerCharacter = "." | '"' | "'" | "`" | "/" | "@" | "<" | "#" | " ";
6460    enum CompletionTriggerKind {
6461        /** Completion was triggered by typing an identifier, manual invocation (e.g Ctrl+Space) or via API. */
6462        Invoked = 1,
6463        /** Completion was triggered by a trigger character. */
6464        TriggerCharacter = 2,
6465        /** Completion was re-triggered as the current completion list is incomplete. */
6466        TriggerForIncompleteCompletions = 3
6467    }
6468    interface GetCompletionsAtPositionOptions extends UserPreferences {
6469        /**
6470         * If the editor is asking for completions because a certain character was typed
6471         * (as opposed to when the user explicitly requested them) this should be set.
6472         */
6473        triggerCharacter?: CompletionsTriggerCharacter;
6474        triggerKind?: CompletionTriggerKind;
6475        /** @deprecated Use includeCompletionsForModuleExports */
6476        includeExternalModuleExports?: boolean;
6477        /** @deprecated Use includeCompletionsWithInsertText */
6478        includeInsertTextCompletions?: boolean;
6479    }
6480    type SignatureHelpTriggerCharacter = "," | "(" | "<";
6481    type SignatureHelpRetriggerCharacter = SignatureHelpTriggerCharacter | ")";
6482    interface SignatureHelpItemsOptions {
6483        triggerReason?: SignatureHelpTriggerReason;
6484    }
6485    type SignatureHelpTriggerReason = SignatureHelpInvokedReason | SignatureHelpCharacterTypedReason | SignatureHelpRetriggeredReason;
6486    /**
6487     * Signals that the user manually requested signature help.
6488     * The language service will unconditionally attempt to provide a result.
6489     */
6490    interface SignatureHelpInvokedReason {
6491        kind: "invoked";
6492        triggerCharacter?: undefined;
6493    }
6494    /**
6495     * Signals that the signature help request came from a user typing a character.
6496     * Depending on the character and the syntactic context, the request may or may not be served a result.
6497     */
6498    interface SignatureHelpCharacterTypedReason {
6499        kind: "characterTyped";
6500        /**
6501         * Character that was responsible for triggering signature help.
6502         */
6503        triggerCharacter: SignatureHelpTriggerCharacter;
6504    }
6505    /**
6506     * Signals that this signature help request came from typing a character or moving the cursor.
6507     * This should only occur if a signature help session was already active and the editor needs to see if it should adjust.
6508     * The language service will unconditionally attempt to provide a result.
6509     * `triggerCharacter` can be `undefined` for a retrigger caused by a cursor move.
6510     */
6511    interface SignatureHelpRetriggeredReason {
6512        kind: "retrigger";
6513        /**
6514         * Character that was responsible for triggering signature help.
6515         */
6516        triggerCharacter?: SignatureHelpRetriggerCharacter;
6517    }
6518    interface ApplyCodeActionCommandResult {
6519        successMessage: string;
6520    }
6521    interface Classifications {
6522        spans: number[];
6523        endOfLineState: EndOfLineState;
6524    }
6525    interface ClassifiedSpan {
6526        textSpan: TextSpan;
6527        classificationType: ClassificationTypeNames;
6528    }
6529    interface ClassifiedSpan2020 {
6530        textSpan: TextSpan;
6531        classificationType: number;
6532    }
6533    /**
6534     * Navigation bar interface designed for visual studio's dual-column layout.
6535     * This does not form a proper tree.
6536     * The navbar is returned as a list of top-level items, each of which has a list of child items.
6537     * Child items always have an empty array for their `childItems`.
6538     */
6539    interface NavigationBarItem {
6540        text: string;
6541        kind: ScriptElementKind;
6542        kindModifiers: string;
6543        spans: TextSpan[];
6544        childItems: NavigationBarItem[];
6545        indent: number;
6546        bolded: boolean;
6547        grayed: boolean;
6548    }
6549    /**
6550     * Node in a tree of nested declarations in a file.
6551     * The top node is always a script or module node.
6552     */
6553    interface NavigationTree {
6554        /** Name of the declaration, or a short description, e.g. "<class>". */
6555        text: string;
6556        kind: ScriptElementKind;
6557        /** ScriptElementKindModifier separated by commas, e.g. "public,abstract" */
6558        kindModifiers: string;
6559        /**
6560         * Spans of the nodes that generated this declaration.
6561         * There will be more than one if this is the result of merging.
6562         */
6563        spans: TextSpan[];
6564        nameSpan: TextSpan | undefined;
6565        /** Present if non-empty */
6566        childItems?: NavigationTree[];
6567    }
6568    interface CallHierarchyItem {
6569        name: string;
6570        kind: ScriptElementKind;
6571        kindModifiers?: string;
6572        file: string;
6573        span: TextSpan;
6574        selectionSpan: TextSpan;
6575        containerName?: string;
6576    }
6577    interface CallHierarchyIncomingCall {
6578        from: CallHierarchyItem;
6579        fromSpans: TextSpan[];
6580    }
6581    interface CallHierarchyOutgoingCall {
6582        to: CallHierarchyItem;
6583        fromSpans: TextSpan[];
6584    }
6585    enum InlayHintKind {
6586        Type = "Type",
6587        Parameter = "Parameter",
6588        Enum = "Enum"
6589    }
6590    interface InlayHint {
6591        text: string;
6592        position: number;
6593        kind: InlayHintKind;
6594        whitespaceBefore?: boolean;
6595        whitespaceAfter?: boolean;
6596    }
6597    interface TodoCommentDescriptor {
6598        text: string;
6599        priority: number;
6600    }
6601    interface TodoComment {
6602        descriptor: TodoCommentDescriptor;
6603        message: string;
6604        position: number;
6605    }
6606    interface TextChange {
6607        span: TextSpan;
6608        newText: string;
6609    }
6610    interface FileTextChanges {
6611        fileName: string;
6612        textChanges: readonly TextChange[];
6613        isNewFile?: boolean;
6614    }
6615    interface CodeAction {
6616        /** Description of the code action to display in the UI of the editor */
6617        description: string;
6618        /** Text changes to apply to each file as part of the code action */
6619        changes: FileTextChanges[];
6620        /**
6621         * If the user accepts the code fix, the editor should send the action back in a `applyAction` request.
6622         * This allows the language service to have side effects (e.g. installing dependencies) upon a code fix.
6623         */
6624        commands?: CodeActionCommand[];
6625    }
6626    interface CodeFixAction extends CodeAction {
6627        /** Short name to identify the fix, for use by telemetry. */
6628        fixName: string;
6629        /**
6630         * If present, one may call 'getCombinedCodeFix' with this fixId.
6631         * This may be omitted to indicate that the code fix can't be applied in a group.
6632         */
6633        fixId?: {};
6634        fixAllDescription?: string;
6635    }
6636    interface CombinedCodeActions {
6637        changes: readonly FileTextChanges[];
6638        commands?: readonly CodeActionCommand[];
6639    }
6640    type CodeActionCommand = InstallPackageAction;
6641    interface InstallPackageAction {
6642    }
6643    /**
6644     * A set of one or more available refactoring actions, grouped under a parent refactoring.
6645     */
6646    interface ApplicableRefactorInfo {
6647        /**
6648         * The programmatic name of the refactoring
6649         */
6650        name: string;
6651        /**
6652         * A description of this refactoring category to show to the user.
6653         * If the refactoring gets inlined (see below), this text will not be visible.
6654         */
6655        description: string;
6656        /**
6657         * Inlineable refactorings can have their actions hoisted out to the top level
6658         * of a context menu. Non-inlineanable refactorings should always be shown inside
6659         * their parent grouping.
6660         *
6661         * If not specified, this value is assumed to be 'true'
6662         */
6663        inlineable?: boolean;
6664        actions: RefactorActionInfo[];
6665    }
6666    /**
6667     * Represents a single refactoring action - for example, the "Extract Method..." refactor might
6668     * offer several actions, each corresponding to a surround class or closure to extract into.
6669     */
6670    interface RefactorActionInfo {
6671        /**
6672         * The programmatic name of the refactoring action
6673         */
6674        name: string;
6675        /**
6676         * A description of this refactoring action to show to the user.
6677         * If the parent refactoring is inlined away, this will be the only text shown,
6678         * so this description should make sense by itself if the parent is inlineable=true
6679         */
6680        description: string;
6681        /**
6682         * A message to show to the user if the refactoring cannot be applied in
6683         * the current context.
6684         */
6685        notApplicableReason?: string;
6686        /**
6687         * The hierarchical dotted name of the refactor action.
6688         */
6689        kind?: string;
6690    }
6691    /**
6692     * A set of edits to make in response to a refactor action, plus an optional
6693     * location where renaming should be invoked from
6694     */
6695    interface RefactorEditInfo {
6696        edits: FileTextChanges[];
6697        renameFilename?: string;
6698        renameLocation?: number;
6699        commands?: CodeActionCommand[];
6700    }
6701    type RefactorTriggerReason = "implicit" | "invoked";
6702    interface TextInsertion {
6703        newText: string;
6704        /** The position in newText the caret should point to after the insertion. */
6705        caretOffset: number;
6706    }
6707    interface DocumentSpan {
6708        textSpan: TextSpan;
6709        fileName: string;
6710        /**
6711         * If the span represents a location that was remapped (e.g. via a .d.ts.map file),
6712         * then the original filename and span will be specified here
6713         */
6714        originalTextSpan?: TextSpan;
6715        originalFileName?: string;
6716        /**
6717         * If DocumentSpan.textSpan is the span for name of the declaration,
6718         * then this is the span for relevant declaration
6719         */
6720        contextSpan?: TextSpan;
6721        originalContextSpan?: TextSpan;
6722    }
6723    interface RenameLocation extends DocumentSpan {
6724        readonly prefixText?: string;
6725        readonly suffixText?: string;
6726    }
6727    interface ReferenceEntry extends DocumentSpan {
6728        isWriteAccess: boolean;
6729        isInString?: true;
6730    }
6731    interface ImplementationLocation extends DocumentSpan {
6732        kind: ScriptElementKind;
6733        displayParts: SymbolDisplayPart[];
6734    }
6735    enum HighlightSpanKind {
6736        none = "none",
6737        definition = "definition",
6738        reference = "reference",
6739        writtenReference = "writtenReference"
6740    }
6741    interface HighlightSpan {
6742        fileName?: string;
6743        isInString?: true;
6744        textSpan: TextSpan;
6745        contextSpan?: TextSpan;
6746        kind: HighlightSpanKind;
6747    }
6748    interface NavigateToItem {
6749        name: string;
6750        kind: ScriptElementKind;
6751        kindModifiers: string;
6752        matchKind: "exact" | "prefix" | "substring" | "camelCase";
6753        isCaseSensitive: boolean;
6754        fileName: string;
6755        textSpan: TextSpan;
6756        containerName: string;
6757        containerKind: ScriptElementKind;
6758    }
6759    enum IndentStyle {
6760        None = 0,
6761        Block = 1,
6762        Smart = 2
6763    }
6764    enum SemicolonPreference {
6765        Ignore = "ignore",
6766        Insert = "insert",
6767        Remove = "remove"
6768    }
6769    /** @deprecated - consider using EditorSettings instead */
6770    interface EditorOptions {
6771        BaseIndentSize?: number;
6772        IndentSize: number;
6773        TabSize: number;
6774        NewLineCharacter: string;
6775        ConvertTabsToSpaces: boolean;
6776        IndentStyle: IndentStyle;
6777    }
6778    interface EditorSettings {
6779        baseIndentSize?: number;
6780        indentSize?: number;
6781        tabSize?: number;
6782        newLineCharacter?: string;
6783        convertTabsToSpaces?: boolean;
6784        indentStyle?: IndentStyle;
6785        trimTrailingWhitespace?: boolean;
6786    }
6787    /** @deprecated - consider using FormatCodeSettings instead */
6788    interface FormatCodeOptions extends EditorOptions {
6789        InsertSpaceAfterCommaDelimiter: boolean;
6790        InsertSpaceAfterSemicolonInForStatements: boolean;
6791        InsertSpaceBeforeAndAfterBinaryOperators: boolean;
6792        InsertSpaceAfterConstructor?: boolean;
6793        InsertSpaceAfterKeywordsInControlFlowStatements: boolean;
6794        InsertSpaceAfterFunctionKeywordForAnonymousFunctions: boolean;
6795        InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: boolean;
6796        InsertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: boolean;
6797        InsertSpaceAfterOpeningAndBeforeClosingNonemptyBraces?: boolean;
6798        InsertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: boolean;
6799        InsertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces?: boolean;
6800        InsertSpaceAfterTypeAssertion?: boolean;
6801        InsertSpaceBeforeFunctionParenthesis?: boolean;
6802        PlaceOpenBraceOnNewLineForFunctions: boolean;
6803        PlaceOpenBraceOnNewLineForControlBlocks: boolean;
6804        insertSpaceBeforeTypeAnnotation?: boolean;
6805    }
6806    interface FormatCodeSettings extends EditorSettings {
6807        readonly insertSpaceAfterCommaDelimiter?: boolean;
6808        readonly insertSpaceAfterSemicolonInForStatements?: boolean;
6809        readonly insertSpaceBeforeAndAfterBinaryOperators?: boolean;
6810        readonly insertSpaceAfterConstructor?: boolean;
6811        readonly insertSpaceAfterKeywordsInControlFlowStatements?: boolean;
6812        readonly insertSpaceAfterFunctionKeywordForAnonymousFunctions?: boolean;
6813        readonly insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis?: boolean;
6814        readonly insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets?: boolean;
6815        readonly insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces?: boolean;
6816        readonly insertSpaceAfterOpeningAndBeforeClosingEmptyBraces?: boolean;
6817        readonly insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces?: boolean;
6818        readonly insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces?: boolean;
6819        readonly insertSpaceAfterTypeAssertion?: boolean;
6820        readonly insertSpaceBeforeFunctionParenthesis?: boolean;
6821        readonly placeOpenBraceOnNewLineForFunctions?: boolean;
6822        readonly placeOpenBraceOnNewLineForControlBlocks?: boolean;
6823        readonly insertSpaceBeforeTypeAnnotation?: boolean;
6824        readonly indentMultiLineObjectLiteralBeginningOnBlankLine?: boolean;
6825        readonly semicolons?: SemicolonPreference;
6826    }
6827    function getDefaultFormatCodeSettings(newLineCharacter?: string): FormatCodeSettings;
6828    interface DefinitionInfo extends DocumentSpan {
6829        kind: ScriptElementKind;
6830        name: string;
6831        containerKind: ScriptElementKind;
6832        containerName: string;
6833        unverified?: boolean;
6834    }
6835    interface DefinitionInfoAndBoundSpan {
6836        definitions?: readonly DefinitionInfo[];
6837        textSpan: TextSpan;
6838    }
6839    interface ReferencedSymbolDefinitionInfo extends DefinitionInfo {
6840        displayParts: SymbolDisplayPart[];
6841    }
6842    interface ReferencedSymbol {
6843        definition: ReferencedSymbolDefinitionInfo;
6844        references: ReferencedSymbolEntry[];
6845    }
6846    interface ReferencedSymbolEntry extends ReferenceEntry {
6847        isDefinition?: boolean;
6848    }
6849    enum SymbolDisplayPartKind {
6850        aliasName = 0,
6851        className = 1,
6852        enumName = 2,
6853        fieldName = 3,
6854        interfaceName = 4,
6855        keyword = 5,
6856        lineBreak = 6,
6857        numericLiteral = 7,
6858        stringLiteral = 8,
6859        localName = 9,
6860        methodName = 10,
6861        moduleName = 11,
6862        operator = 12,
6863        parameterName = 13,
6864        propertyName = 14,
6865        punctuation = 15,
6866        space = 16,
6867        text = 17,
6868        typeParameterName = 18,
6869        enumMemberName = 19,
6870        functionName = 20,
6871        regularExpressionLiteral = 21,
6872        link = 22,
6873        linkName = 23,
6874        linkText = 24
6875    }
6876    interface SymbolDisplayPart {
6877        text: string;
6878        kind: string;
6879    }
6880    interface JSDocLinkDisplayPart extends SymbolDisplayPart {
6881        target: DocumentSpan;
6882    }
6883    interface JSDocTagInfo {
6884        name: string;
6885        text?: SymbolDisplayPart[] | string;
6886        index?: number;
6887    }
6888    interface QuickInfo {
6889        kind: ScriptElementKind;
6890        kindModifiers: string;
6891        textSpan: TextSpan;
6892        displayParts?: SymbolDisplayPart[];
6893        documentation?: SymbolDisplayPart[];
6894        tags?: JSDocTagInfo[];
6895    }
6896    type RenameInfo = RenameInfoSuccess | RenameInfoFailure;
6897    interface RenameInfoSuccess {
6898        canRename: true;
6899        /**
6900         * File or directory to rename.
6901         * If set, `getEditsForFileRename` should be called instead of `findRenameLocations`.
6902         */
6903        fileToRename?: string;
6904        displayName: string;
6905        fullDisplayName: string;
6906        kind: ScriptElementKind;
6907        kindModifiers: string;
6908        triggerSpan: TextSpan;
6909    }
6910    interface RenameInfoFailure {
6911        canRename: false;
6912        localizedErrorMessage: string;
6913    }
6914    /**
6915     * @deprecated Use `UserPreferences` instead.
6916     */
6917    interface RenameInfoOptions {
6918        readonly allowRenameOfImportPath?: boolean;
6919    }
6920    interface DocCommentTemplateOptions {
6921        readonly generateReturnInDocTemplate?: boolean;
6922    }
6923    interface SignatureHelpParameter {
6924        name: string;
6925        documentation: SymbolDisplayPart[];
6926        displayParts: SymbolDisplayPart[];
6927        isOptional: boolean;
6928        isRest?: boolean;
6929    }
6930    interface SelectionRange {
6931        textSpan: TextSpan;
6932        parent?: SelectionRange;
6933    }
6934    /**
6935     * Represents a single signature to show in signature help.
6936     * The id is used for subsequent calls into the language service to ask questions about the
6937     * signature help item in the context of any documents that have been updated.  i.e. after
6938     * an edit has happened, while signature help is still active, the host can ask important
6939     * questions like 'what parameter is the user currently contained within?'.
6940     */
6941    interface SignatureHelpItem {
6942        isVariadic: boolean;
6943        prefixDisplayParts: SymbolDisplayPart[];
6944        suffixDisplayParts: SymbolDisplayPart[];
6945        separatorDisplayParts: SymbolDisplayPart[];
6946        parameters: SignatureHelpParameter[];
6947        documentation: SymbolDisplayPart[];
6948        tags: JSDocTagInfo[];
6949    }
6950    /**
6951     * Represents a set of signature help items, and the preferred item that should be selected.
6952     */
6953    interface SignatureHelpItems {
6954        items: SignatureHelpItem[];
6955        applicableSpan: TextSpan;
6956        selectedItemIndex: number;
6957        argumentIndex: number;
6958        argumentCount: number;
6959    }
6960    enum CompletionInfoFlags {
6961        None = 0,
6962        MayIncludeAutoImports = 1,
6963        IsImportStatementCompletion = 2,
6964        IsContinuation = 4,
6965        ResolvedModuleSpecifiers = 8,
6966        ResolvedModuleSpecifiersBeyondLimit = 16,
6967        MayIncludeMethodSnippets = 32
6968    }
6969    interface CompletionInfo {
6970        /** For performance telemetry. */
6971        flags?: CompletionInfoFlags;
6972        /** Not true for all global completions. This will be true if the enclosing scope matches a few syntax kinds. See `isSnippetScope`. */
6973        isGlobalCompletion: boolean;
6974        isMemberCompletion: boolean;
6975        /**
6976         * In the absence of `CompletionEntry["replacementSpan"]`, the editor may choose whether to use
6977         * this span or its default one. If `CompletionEntry["replacementSpan"]` is defined, that span
6978         * must be used to commit that completion entry.
6979         */
6980        optionalReplacementSpan?: TextSpan;
6981        /**
6982         * true when the current location also allows for a new identifier
6983         */
6984        isNewIdentifierLocation: boolean;
6985        /**
6986         * Indicates to client to continue requesting completions on subsequent keystrokes.
6987         */
6988        isIncomplete?: true;
6989        entries: CompletionEntry[];
6990    }
6991    interface CompletionEntryDataAutoImport {
6992        /**
6993         * The name of the property or export in the module's symbol table. Differs from the completion name
6994         * in the case of InternalSymbolName.ExportEquals and InternalSymbolName.Default.
6995         */
6996        exportName: string;
6997        moduleSpecifier?: string;
6998        /** The file name declaring the export's module symbol, if it was an external module */
6999        fileName?: string;
7000        /** The module name (with quotes stripped) of the export's module symbol, if it was an ambient module */
7001        ambientModuleName?: string;
7002        /** True if the export was found in the package.json AutoImportProvider */
7003        isPackageJsonImport?: true;
7004    }
7005    interface CompletionEntryDataUnresolved extends CompletionEntryDataAutoImport {
7006        /** The key in the `ExportMapCache` where the completion entry's `SymbolExportInfo[]` is found */
7007        exportMapKey: string;
7008    }
7009    interface CompletionEntryDataResolved extends CompletionEntryDataAutoImport {
7010        moduleSpecifier: string;
7011    }
7012    type CompletionEntryData = CompletionEntryDataUnresolved | CompletionEntryDataResolved;
7013    interface CompletionEntry {
7014        name: string;
7015        kind: ScriptElementKind;
7016        kindModifiers?: string;
7017        sortText: string;
7018        insertText?: string;
7019        isSnippet?: true;
7020        /**
7021         * An optional span that indicates the text to be replaced by this completion item.
7022         * If present, this span should be used instead of the default one.
7023         * It will be set if the required span differs from the one generated by the default replacement behavior.
7024         */
7025        replacementSpan?: TextSpan;
7026        hasAction?: true;
7027        source?: string;
7028        sourceDisplay?: SymbolDisplayPart[];
7029        labelDetails?: CompletionEntryLabelDetails;
7030        isRecommended?: true;
7031        isFromUncheckedFile?: true;
7032        isPackageJsonImport?: true;
7033        isImportStatementCompletion?: true;
7034        /**
7035         * A property to be sent back to TS Server in the CompletionDetailsRequest, along with `name`,
7036         * that allows TS Server to look up the symbol represented by the completion item, disambiguating
7037         * items with the same name. Currently only defined for auto-import completions, but the type is
7038         * `unknown` in the protocol, so it can be changed as needed to support other kinds of completions.
7039         * The presence of this property should generally not be used to assume that this completion entry
7040         * is an auto-import.
7041         */
7042        data?: CompletionEntryData;
7043        jsDoc?: JSDocTagInfo[];
7044        displayParts?: SymbolDisplayPart[];
7045    }
7046    interface CompletionEntryLabelDetails {
7047        detail?: string;
7048        description?: string;
7049    }
7050    interface CompletionEntryDetails {
7051        name: string;
7052        kind: ScriptElementKind;
7053        kindModifiers: string;
7054        displayParts: SymbolDisplayPart[];
7055        documentation?: SymbolDisplayPart[];
7056        tags?: JSDocTagInfo[];
7057        codeActions?: CodeAction[];
7058        /** @deprecated Use `sourceDisplay` instead. */
7059        source?: SymbolDisplayPart[];
7060        sourceDisplay?: SymbolDisplayPart[];
7061    }
7062    interface OutliningSpan {
7063        /** The span of the document to actually collapse. */
7064        textSpan: TextSpan;
7065        /** The span of the document to display when the user hovers over the collapsed span. */
7066        hintSpan: TextSpan;
7067        /** The text to display in the editor for the collapsed region. */
7068        bannerText: string;
7069        /**
7070         * Whether or not this region should be automatically collapsed when
7071         * the 'Collapse to Definitions' command is invoked.
7072         */
7073        autoCollapse: boolean;
7074        /**
7075         * Classification of the contents of the span
7076         */
7077        kind: OutliningSpanKind;
7078    }
7079    enum OutliningSpanKind {
7080        /** Single or multi-line comments */
7081        Comment = "comment",
7082        /** Sections marked by '// #region' and '// #endregion' comments */
7083        Region = "region",
7084        /** Declarations and expressions */
7085        Code = "code",
7086        /** Contiguous blocks of import declarations */
7087        Imports = "imports"
7088    }
7089    enum OutputFileType {
7090        JavaScript = 0,
7091        SourceMap = 1,
7092        Declaration = 2
7093    }
7094    enum EndOfLineState {
7095        None = 0,
7096        InMultiLineCommentTrivia = 1,
7097        InSingleQuoteStringLiteral = 2,
7098        InDoubleQuoteStringLiteral = 3,
7099        InTemplateHeadOrNoSubstitutionTemplate = 4,
7100        InTemplateMiddleOrTail = 5,
7101        InTemplateSubstitutionPosition = 6
7102    }
7103    enum TokenClass {
7104        Punctuation = 0,
7105        Keyword = 1,
7106        Operator = 2,
7107        Comment = 3,
7108        Whitespace = 4,
7109        Identifier = 5,
7110        NumberLiteral = 6,
7111        BigIntLiteral = 7,
7112        StringLiteral = 8,
7113        RegExpLiteral = 9
7114    }
7115    interface ClassificationResult {
7116        finalLexState: EndOfLineState;
7117        entries: ClassificationInfo[];
7118    }
7119    interface ClassificationInfo {
7120        length: number;
7121        classification: TokenClass;
7122    }
7123    interface Classifier {
7124        /**
7125         * Gives lexical classifications of tokens on a line without any syntactic context.
7126         * For instance, a token consisting of the text 'string' can be either an identifier
7127         * named 'string' or the keyword 'string', however, because this classifier is not aware,
7128         * it relies on certain heuristics to give acceptable results. For classifications where
7129         * speed trumps accuracy, this function is preferable; however, for true accuracy, the
7130         * syntactic classifier is ideal. In fact, in certain editing scenarios, combining the
7131         * lexical, syntactic, and semantic classifiers may issue the best user experience.
7132         *
7133         * @param text                      The text of a line to classify.
7134         * @param lexState                  The state of the lexical classifier at the end of the previous line.
7135         * @param syntacticClassifierAbsent Whether the client is *not* using a syntactic classifier.
7136         *                                  If there is no syntactic classifier (syntacticClassifierAbsent=true),
7137         *                                  certain heuristics may be used in its place; however, if there is a
7138         *                                  syntactic classifier (syntacticClassifierAbsent=false), certain
7139         *                                  classifications which may be incorrectly categorized will be given
7140         *                                  back as Identifiers in order to allow the syntactic classifier to
7141         *                                  subsume the classification.
7142         * @deprecated Use getLexicalClassifications instead.
7143         */
7144        getClassificationsForLine(text: string, lexState: EndOfLineState, syntacticClassifierAbsent: boolean): ClassificationResult;
7145        getEncodedLexicalClassifications(text: string, endOfLineState: EndOfLineState, syntacticClassifierAbsent: boolean): Classifications;
7146    }
7147    enum ScriptElementKind {
7148        unknown = "",
7149        warning = "warning",
7150        /** predefined type (void) or keyword (class) */
7151        keyword = "keyword",
7152        /** top level script node */
7153        scriptElement = "script",
7154        /** module foo {} */
7155        moduleElement = "module",
7156        /** class X {} */
7157        classElement = "class",
7158        /** var x = class X {} */
7159        localClassElement = "local class",
7160        /** struct X {} */
7161        structElement = "struct",
7162        /** interface Y {} */
7163        interfaceElement = "interface",
7164        /** type T = ... */
7165        typeElement = "type",
7166        /** enum E */
7167        enumElement = "enum",
7168        enumMemberElement = "enum member",
7169        /**
7170         * Inside module and script only
7171         * const v = ..
7172         */
7173        variableElement = "var",
7174        /** Inside function */
7175        localVariableElement = "local var",
7176        /**
7177         * Inside module and script only
7178         * function f() { }
7179         */
7180        functionElement = "function",
7181        /** Inside function */
7182        localFunctionElement = "local function",
7183        /** class X { [public|private]* foo() {} } */
7184        memberFunctionElement = "method",
7185        /** class X { [public|private]* [get|set] foo:number; } */
7186        memberGetAccessorElement = "getter",
7187        memberSetAccessorElement = "setter",
7188        /**
7189         * class X { [public|private]* foo:number; }
7190         * interface Y { foo:number; }
7191         */
7192        memberVariableElement = "property",
7193        /** class X { [public|private]* accessor foo: number; } */
7194        memberAccessorVariableElement = "accessor",
7195        /**
7196         * class X { constructor() { } }
7197         * class X { static { } }
7198         */
7199        constructorImplementationElement = "constructor",
7200        /** interface Y { ():number; } */
7201        callSignatureElement = "call",
7202        /** interface Y { []:number; } */
7203        indexSignatureElement = "index",
7204        /** interface Y { new():Y; } */
7205        constructSignatureElement = "construct",
7206        /** function foo(*Y*: string) */
7207        parameterElement = "parameter",
7208        typeParameterElement = "type parameter",
7209        primitiveType = "primitive type",
7210        label = "label",
7211        alias = "alias",
7212        constElement = "const",
7213        letElement = "let",
7214        directory = "directory",
7215        externalModuleName = "external module name",
7216        /**
7217         * <JsxTagName attribute1 attribute2={0} />
7218         * @deprecated
7219         */
7220        jsxAttribute = "JSX attribute",
7221        /** String literal */
7222        string = "string",
7223        /** Jsdoc @link: in `{@link C link text}`, the before and after text "{@link " and "}" */
7224        link = "link",
7225        /** Jsdoc @link: in `{@link C link text}`, the entity name "C" */
7226        linkName = "link name",
7227        /** Jsdoc @link: in `{@link C link text}`, the link text "link text" */
7228        linkText = "link text"
7229    }
7230    enum ScriptElementKindModifier {
7231        none = "",
7232        publicMemberModifier = "public",
7233        privateMemberModifier = "private",
7234        protectedMemberModifier = "protected",
7235        exportedModifier = "export",
7236        ambientModifier = "declare",
7237        staticModifier = "static",
7238        abstractModifier = "abstract",
7239        optionalModifier = "optional",
7240        deprecatedModifier = "deprecated",
7241        dtsModifier = ".d.ts",
7242        tsModifier = ".ts",
7243        tsxModifier = ".tsx",
7244        jsModifier = ".js",
7245        jsxModifier = ".jsx",
7246        jsonModifier = ".json",
7247        dmtsModifier = ".d.mts",
7248        mtsModifier = ".mts",
7249        mjsModifier = ".mjs",
7250        dctsModifier = ".d.cts",
7251        ctsModifier = ".cts",
7252        cjsModifier = ".cjs",
7253        etsModifier = ".ets",
7254        detsModifier = ".d.ets"
7255    }
7256    enum ClassificationTypeNames {
7257        comment = "comment",
7258        identifier = "identifier",
7259        keyword = "keyword",
7260        numericLiteral = "number",
7261        bigintLiteral = "bigint",
7262        operator = "operator",
7263        stringLiteral = "string",
7264        whiteSpace = "whitespace",
7265        text = "text",
7266        punctuation = "punctuation",
7267        className = "class name",
7268        enumName = "enum name",
7269        interfaceName = "interface name",
7270        moduleName = "module name",
7271        typeParameterName = "type parameter name",
7272        typeAliasName = "type alias name",
7273        parameterName = "parameter name",
7274        docCommentTagName = "doc comment tag name",
7275        jsxOpenTagName = "jsx open tag name",
7276        jsxCloseTagName = "jsx close tag name",
7277        jsxSelfClosingTagName = "jsx self closing tag name",
7278        jsxAttribute = "jsx attribute",
7279        jsxText = "jsx text",
7280        jsxAttributeStringLiteralValue = "jsx attribute string literal value"
7281    }
7282    enum ClassificationType {
7283        comment = 1,
7284        identifier = 2,
7285        keyword = 3,
7286        numericLiteral = 4,
7287        operator = 5,
7288        stringLiteral = 6,
7289        regularExpressionLiteral = 7,
7290        whiteSpace = 8,
7291        text = 9,
7292        punctuation = 10,
7293        className = 11,
7294        enumName = 12,
7295        interfaceName = 13,
7296        moduleName = 14,
7297        typeParameterName = 15,
7298        typeAliasName = 16,
7299        parameterName = 17,
7300        docCommentTagName = 18,
7301        jsxOpenTagName = 19,
7302        jsxCloseTagName = 20,
7303        jsxSelfClosingTagName = 21,
7304        jsxAttribute = 22,
7305        jsxText = 23,
7306        jsxAttributeStringLiteralValue = 24,
7307        bigintLiteral = 25
7308    }
7309    interface InlayHintsContext {
7310        file: SourceFile;
7311        program: Program;
7312        cancellationToken: CancellationToken;
7313        host: LanguageServiceHost;
7314        span: TextSpan;
7315        preferences: UserPreferences;
7316    }
7317}
7318declare namespace ts {
7319    /** The classifier is used for syntactic highlighting in editors via the TSServer */
7320    function createClassifier(): Classifier;
7321}
7322declare namespace ts {
7323    interface DocumentHighlights {
7324        fileName: string;
7325        highlightSpans: HighlightSpan[];
7326    }
7327}
7328declare namespace ts {
7329    /**
7330     * The document registry represents a store of SourceFile objects that can be shared between
7331     * multiple LanguageService instances. A LanguageService instance holds on the SourceFile (AST)
7332     * of files in the context.
7333     * SourceFile objects account for most of the memory usage by the language service. Sharing
7334     * the same DocumentRegistry instance between different instances of LanguageService allow
7335     * for more efficient memory utilization since all projects will share at least the library
7336     * file (lib.d.ts).
7337     *
7338     * A more advanced use of the document registry is to serialize sourceFile objects to disk
7339     * and re-hydrate them when needed.
7340     *
7341     * To create a default DocumentRegistry, use createDocumentRegistry to create one, and pass it
7342     * to all subsequent createLanguageService calls.
7343     */
7344    interface DocumentRegistry {
7345        /**
7346         * Request a stored SourceFile with a given fileName and compilationSettings.
7347         * The first call to acquire will call createLanguageServiceSourceFile to generate
7348         * the SourceFile if was not found in the registry.
7349         *
7350         * @param fileName The name of the file requested
7351         * @param compilationSettingsOrHost Some compilation settings like target affects the
7352         * shape of a the resulting SourceFile. This allows the DocumentRegistry to store
7353         * multiple copies of the same file for different compilation settings. A minimal
7354         * resolution cache is needed to fully define a source file's shape when
7355         * the compilation settings include `module: node16`+, so providing a cache host
7356         * object should be preferred. A common host is a language service `ConfiguredProject`.
7357         * @param scriptSnapshot Text of the file. Only used if the file was not found
7358         * in the registry and a new one was created.
7359         * @param version Current version of the file. Only used if the file was not found
7360         * in the registry and a new one was created.
7361         */
7362        acquireDocument(fileName: string, compilationSettingsOrHost: CompilerOptions | MinimalResolutionCacheHost, scriptSnapshot: IScriptSnapshot, version: string, scriptKind?: ScriptKind, sourceFileOptions?: CreateSourceFileOptions | ScriptTarget): SourceFile;
7363        acquireDocumentWithKey(fileName: string, path: Path, compilationSettingsOrHost: CompilerOptions | MinimalResolutionCacheHost, key: DocumentRegistryBucketKey, scriptSnapshot: IScriptSnapshot, version: string, scriptKind?: ScriptKind, sourceFileOptions?: CreateSourceFileOptions | ScriptTarget): SourceFile;
7364        /**
7365         * Request an updated version of an already existing SourceFile with a given fileName
7366         * and compilationSettings. The update will in-turn call updateLanguageServiceSourceFile
7367         * to get an updated SourceFile.
7368         *
7369         * @param fileName The name of the file requested
7370         * @param compilationSettingsOrHost Some compilation settings like target affects the
7371         * shape of a the resulting SourceFile. This allows the DocumentRegistry to store
7372         * multiple copies of the same file for different compilation settings. A minimal
7373         * resolution cache is needed to fully define a source file's shape when
7374         * the compilation settings include `module: node16`+, so providing a cache host
7375         * object should be preferred. A common host is a language service `ConfiguredProject`.
7376         * @param scriptSnapshot Text of the file.
7377         * @param version Current version of the file.
7378         */
7379        updateDocument(fileName: string, compilationSettingsOrHost: CompilerOptions | MinimalResolutionCacheHost, scriptSnapshot: IScriptSnapshot, version: string, scriptKind?: ScriptKind, sourceFileOptions?: CreateSourceFileOptions | ScriptTarget): SourceFile;
7380        updateDocumentWithKey(fileName: string, path: Path, compilationSettingsOrHost: CompilerOptions | MinimalResolutionCacheHost, key: DocumentRegistryBucketKey, scriptSnapshot: IScriptSnapshot, version: string, scriptKind?: ScriptKind, sourceFileOptions?: CreateSourceFileOptions | ScriptTarget): SourceFile;
7381        getKeyForCompilationSettings(settings: CompilerOptions): DocumentRegistryBucketKey;
7382        /**
7383         * Informs the DocumentRegistry that a file is not needed any longer.
7384         *
7385         * Note: It is not allowed to call release on a SourceFile that was not acquired from
7386         * this registry originally.
7387         *
7388         * @param fileName The name of the file to be released
7389         * @param compilationSettings The compilation settings used to acquire the file
7390         * @param scriptKind The script kind of the file to be released
7391         */
7392        /**@deprecated pass scriptKind and impliedNodeFormat for correctness */
7393        releaseDocument(fileName: string, compilationSettings: CompilerOptions, scriptKind?: ScriptKind): void;
7394        /**
7395         * Informs the DocumentRegistry that a file is not needed any longer.
7396         *
7397         * Note: It is not allowed to call release on a SourceFile that was not acquired from
7398         * this registry originally.
7399         *
7400         * @param fileName The name of the file to be released
7401         * @param compilationSettings The compilation settings used to acquire the file
7402         * @param scriptKind The script kind of the file to be released
7403         * @param impliedNodeFormat The implied source file format of the file to be released
7404         */
7405        releaseDocument(fileName: string, compilationSettings: CompilerOptions, scriptKind: ScriptKind, impliedNodeFormat: SourceFile["impliedNodeFormat"]): void;
7406        /**
7407         * @deprecated pass scriptKind for and impliedNodeFormat correctness */
7408        releaseDocumentWithKey(path: Path, key: DocumentRegistryBucketKey, scriptKind?: ScriptKind): void;
7409        releaseDocumentWithKey(path: Path, key: DocumentRegistryBucketKey, scriptKind: ScriptKind, impliedNodeFormat: SourceFile["impliedNodeFormat"]): void;
7410        reportStats(): string;
7411    }
7412    type DocumentRegistryBucketKey = string & {
7413        __bucketKey: any;
7414    };
7415    function createDocumentRegistry(useCaseSensitiveFileNames?: boolean, currentDirectory?: string): DocumentRegistry;
7416}
7417declare namespace ts {
7418    function preProcessFile(sourceText: string, readImportFiles?: boolean, detectJavaScriptImports?: boolean): PreProcessedFileInfo;
7419}
7420declare namespace ts {
7421    interface TranspileOptions {
7422        compilerOptions?: CompilerOptions;
7423        fileName?: string;
7424        reportDiagnostics?: boolean;
7425        moduleName?: string;
7426        renamedDependencies?: MapLike<string>;
7427        transformers?: CustomTransformers;
7428    }
7429    interface TranspileOutput {
7430        outputText: string;
7431        diagnostics?: Diagnostic[];
7432        sourceMapText?: string;
7433    }
7434    function transpileModule(input: string, transpileOptions: TranspileOptions): TranspileOutput;
7435    function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[], moduleName?: string): string;
7436}
7437declare namespace ts {
7438    /** The version of the language service API */
7439    const servicesVersion = "0.8";
7440    function toEditorSettings(options: EditorOptions | EditorSettings): EditorSettings;
7441    function displayPartsToString(displayParts: SymbolDisplayPart[] | undefined): string;
7442    function getDefaultCompilerOptions(): CompilerOptions;
7443    function getSupportedCodeFixes(): string[];
7444    function createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTargetOrOptions: ScriptTarget | CreateSourceFileOptions, version: string, setNodeParents: boolean, scriptKind?: ScriptKind, option?: CompilerOptions): SourceFile;
7445    function updateLanguageServiceSourceFile(sourceFile: SourceFile, scriptSnapshot: IScriptSnapshot, version: string, textChangeRange: TextChangeRange | undefined, aggressiveChecks?: boolean, option?: CompilerOptions): SourceFile;
7446    function createLanguageService(host: LanguageServiceHost, documentRegistry?: DocumentRegistry, syntaxOnlyOrLanguageServiceMode?: boolean | LanguageServiceMode): LanguageService;
7447    /**
7448     * Get the path of the default library files (lib.d.ts) as distributed with the typescript
7449     * node package.
7450     * The functionality is not supported if the ts module is consumed outside of a node module.
7451     */
7452    function getDefaultLibFilePath(options: CompilerOptions): string;
7453}
7454declare namespace ts {
7455    /**
7456     * Transform one or more nodes using the supplied transformers.
7457     * @param source A single `Node` or an array of `Node` objects.
7458     * @param transformers An array of `TransformerFactory` callbacks used to process the transformation.
7459     * @param compilerOptions Optional compiler options.
7460     */
7461    function transform<T extends Node>(source: T | T[], transformers: TransformerFactory<T>[], compilerOptions?: CompilerOptions): TransformationResult<T>;
7462}
7463declare namespace ts {
7464    /** @deprecated Use `factory.createNodeArray` or the factory supplied by your transformation context instead. */
7465    const createNodeArray: <T extends Node>(elements?: readonly T[] | undefined, hasTrailingComma?: boolean | undefined) => NodeArray<T>;
7466    /** @deprecated Use `factory.createNumericLiteral` or the factory supplied by your transformation context instead. */
7467    const createNumericLiteral: (value: string | number, numericLiteralFlags?: TokenFlags | undefined) => NumericLiteral;
7468    /** @deprecated Use `factory.createBigIntLiteral` or the factory supplied by your transformation context instead. */
7469    const createBigIntLiteral: (value: string | PseudoBigInt) => BigIntLiteral;
7470    /** @deprecated Use `factory.createStringLiteral` or the factory supplied by your transformation context instead. */
7471    const createStringLiteral: {
7472        (text: string, isSingleQuote?: boolean | undefined): StringLiteral;
7473        (text: string, isSingleQuote?: boolean | undefined, hasExtendedUnicodeEscape?: boolean | undefined): StringLiteral;
7474    };
7475    /** @deprecated Use `factory.createStringLiteralFromNode` or the factory supplied by your transformation context instead. */
7476    const createStringLiteralFromNode: (sourceNode: PrivateIdentifier | PropertyNameLiteral, isSingleQuote?: boolean | undefined) => StringLiteral;
7477    /** @deprecated Use `factory.createRegularExpressionLiteral` or the factory supplied by your transformation context instead. */
7478    const createRegularExpressionLiteral: (text: string) => RegularExpressionLiteral;
7479    /** @deprecated Use `factory.createLoopVariable` or the factory supplied by your transformation context instead. */
7480    const createLoopVariable: (reservedInNestedScopes?: boolean | undefined) => Identifier;
7481    /** @deprecated Use `factory.createUniqueName` or the factory supplied by your transformation context instead. */
7482    const createUniqueName: (text: string, flags?: GeneratedIdentifierFlags | undefined) => Identifier;
7483    /** @deprecated Use `factory.createPrivateIdentifier` or the factory supplied by your transformation context instead. */
7484    const createPrivateIdentifier: (text: string) => PrivateIdentifier;
7485    /** @deprecated Use `factory.createSuper` or the factory supplied by your transformation context instead. */
7486    const createSuper: () => SuperExpression;
7487    /** @deprecated Use `factory.createThis` or the factory supplied by your transformation context instead. */
7488    const createThis: () => ThisExpression;
7489    /** @deprecated Use `factory.createNull` or the factory supplied by your transformation context instead. */
7490    const createNull: () => NullLiteral;
7491    /** @deprecated Use `factory.createTrue` or the factory supplied by your transformation context instead. */
7492    const createTrue: () => TrueLiteral;
7493    /** @deprecated Use `factory.createFalse` or the factory supplied by your transformation context instead. */
7494    const createFalse: () => FalseLiteral;
7495    /** @deprecated Use `factory.createModifier` or the factory supplied by your transformation context instead. */
7496    const createModifier: <T extends ModifierSyntaxKind>(kind: T) => ModifierToken<T>;
7497    /** @deprecated Use `factory.createModifiersFromModifierFlags` or the factory supplied by your transformation context instead. */
7498    const createModifiersFromModifierFlags: (flags: ModifierFlags) => Modifier[] | undefined;
7499    /** @deprecated Use `factory.createQualifiedName` or the factory supplied by your transformation context instead. */
7500    const createQualifiedName: (left: EntityName, right: string | Identifier) => QualifiedName;
7501    /** @deprecated Use `factory.updateQualifiedName` or the factory supplied by your transformation context instead. */
7502    const updateQualifiedName: (node: QualifiedName, left: EntityName, right: Identifier) => QualifiedName;
7503    /** @deprecated Use `factory.createComputedPropertyName` or the factory supplied by your transformation context instead. */
7504    const createComputedPropertyName: (expression: Expression) => ComputedPropertyName;
7505    /** @deprecated Use `factory.updateComputedPropertyName` or the factory supplied by your transformation context instead. */
7506    const updateComputedPropertyName: (node: ComputedPropertyName, expression: Expression) => ComputedPropertyName;
7507    /** @deprecated Use `factory.createTypeParameterDeclaration` or the factory supplied by your transformation context instead. */
7508    const createTypeParameterDeclaration: {
7509        (modifiers: readonly Modifier[] | undefined, name: string | Identifier, constraint?: TypeNode | undefined, defaultType?: TypeNode | undefined): TypeParameterDeclaration;
7510        (name: string | Identifier, constraint?: TypeNode | undefined, defaultType?: TypeNode | undefined): TypeParameterDeclaration;
7511    };
7512    /** @deprecated Use `factory.updateTypeParameterDeclaration` or the factory supplied by your transformation context instead. */
7513    const updateTypeParameterDeclaration: {
7514        (node: TypeParameterDeclaration, modifiers: readonly Modifier[] | undefined, name: Identifier, constraint: TypeNode | undefined, defaultType: TypeNode | undefined): TypeParameterDeclaration;
7515        (node: TypeParameterDeclaration, name: Identifier, constraint: TypeNode | undefined, defaultType: TypeNode | undefined): TypeParameterDeclaration;
7516    };
7517    /** @deprecated Use `factory.createParameterDeclaration` or the factory supplied by your transformation context instead. */
7518    const createParameter: {
7519        (modifiers: readonly ModifierLike[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken?: QuestionToken | undefined, type?: TypeNode | undefined, initializer?: Expression | undefined): ParameterDeclaration;
7520        (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken?: QuestionToken | undefined, type?: TypeNode | undefined, initializer?: Expression | undefined): ParameterDeclaration;
7521    };
7522    /** @deprecated Use `factory.updateParameterDeclaration` or the factory supplied by your transformation context instead. */
7523    const updateParameter: {
7524        (node: ParameterDeclaration, modifiers: readonly ModifierLike[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): ParameterDeclaration;
7525        (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;
7526    };
7527    /** @deprecated Use `factory.createDecorator` or the factory supplied by your transformation context instead. */
7528    const createDecorator: (expression: Expression) => Decorator;
7529    /** @deprecated Use `factory.updateDecorator` or the factory supplied by your transformation context instead. */
7530    const updateDecorator: (node: Decorator, expression: Expression) => Decorator;
7531    /** @deprecated Use `factory.createPropertyDeclaration` or the factory supplied by your transformation context instead. */
7532    const createProperty: {
7533        (modifiers: readonly ModifierLike[] | undefined, name: string | PropertyName, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertyDeclaration;
7534        (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertyDeclaration;
7535    };
7536    /** @deprecated Use `factory.updatePropertyDeclaration` or the factory supplied by your transformation context instead. */
7537    const updateProperty: {
7538        (node: PropertyDeclaration, modifiers: readonly ModifierLike[] | undefined, name: string | PropertyName, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertyDeclaration;
7539        (node: PropertyDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertyDeclaration;
7540    };
7541    /** @deprecated Use `factory.createMethodDeclaration` or the factory supplied by your transformation context instead. */
7542    const createMethod: {
7543        (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;
7544        (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;
7545    };
7546    /** @deprecated Use `factory.updateMethodDeclaration` or the factory supplied by your transformation context instead. */
7547    const updateMethod: {
7548        (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;
7549        (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;
7550    };
7551    /** @deprecated Use `factory.createConstructorDeclaration` or the factory supplied by your transformation context instead. */
7552    const createConstructor: {
7553        (modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], body: Block | undefined): ConstructorDeclaration;
7554        (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], body: Block | undefined): ConstructorDeclaration;
7555    };
7556    /** @deprecated Use `factory.updateConstructorDeclaration` or the factory supplied by your transformation context instead. */
7557    const updateConstructor: {
7558        (node: ConstructorDeclaration, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], body: Block | undefined): ConstructorDeclaration;
7559        (node: ConstructorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], body: Block | undefined): ConstructorDeclaration;
7560    };
7561    /** @deprecated Use `factory.createGetAccessorDeclaration` or the factory supplied by your transformation context instead. */
7562    const createGetAccessor: {
7563        (modifiers: readonly ModifierLike[] | undefined, name: string | PropertyName, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): GetAccessorDeclaration;
7564        (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): GetAccessorDeclaration;
7565    };
7566    /** @deprecated Use `factory.updateGetAccessorDeclaration` or the factory supplied by your transformation context instead. */
7567    const updateGetAccessor: {
7568        (node: GetAccessorDeclaration, modifiers: readonly ModifierLike[] | undefined, name: PropertyName, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): GetAccessorDeclaration;
7569        (node: GetAccessorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: PropertyName, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): GetAccessorDeclaration;
7570    };
7571    /** @deprecated Use `factory.createSetAccessorDeclaration` or the factory supplied by your transformation context instead. */
7572    const createSetAccessor: {
7573        (modifiers: readonly ModifierLike[] | undefined, name: string | PropertyName, parameters: readonly ParameterDeclaration[], body: Block | undefined): SetAccessorDeclaration;
7574        (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, parameters: readonly ParameterDeclaration[], body: Block | undefined): SetAccessorDeclaration;
7575    };
7576    /** @deprecated Use `factory.updateSetAccessorDeclaration` or the factory supplied by your transformation context instead. */
7577    const updateSetAccessor: {
7578        (node: SetAccessorDeclaration, modifiers: readonly ModifierLike[] | undefined, name: PropertyName, parameters: readonly ParameterDeclaration[], body: Block | undefined): SetAccessorDeclaration;
7579        (node: SetAccessorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: PropertyName, parameters: readonly ParameterDeclaration[], body: Block | undefined): SetAccessorDeclaration;
7580    };
7581    /** @deprecated Use `factory.createCallSignature` or the factory supplied by your transformation context instead. */
7582    const createCallSignature: (typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined) => CallSignatureDeclaration;
7583    /** @deprecated Use `factory.updateCallSignature` or the factory supplied by your transformation context instead. */
7584    const updateCallSignature: (node: CallSignatureDeclaration, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined) => CallSignatureDeclaration;
7585    /** @deprecated Use `factory.createConstructSignature` or the factory supplied by your transformation context instead. */
7586    const createConstructSignature: (typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined) => ConstructSignatureDeclaration;
7587    /** @deprecated Use `factory.updateConstructSignature` or the factory supplied by your transformation context instead. */
7588    const updateConstructSignature: (node: ConstructSignatureDeclaration, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined) => ConstructSignatureDeclaration;
7589    /** @deprecated Use `factory.updateIndexSignature` or the factory supplied by your transformation context instead. */
7590    const updateIndexSignature: {
7591        (node: IndexSignatureDeclaration, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration;
7592        (node: IndexSignatureDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration;
7593    };
7594    /** @deprecated Use `factory.createKeywordTypeNode` or the factory supplied by your transformation context instead. */
7595    const createKeywordTypeNode: <TKind extends KeywordTypeSyntaxKind>(kind: TKind) => KeywordTypeNode<TKind>;
7596    /** @deprecated Use `factory.createTypePredicateNode` or the factory supplied by your transformation context instead. */
7597    const createTypePredicateNodeWithModifier: (assertsModifier: AssertsKeyword | undefined, parameterName: string | Identifier | ThisTypeNode, type: TypeNode | undefined) => TypePredicateNode;
7598    /** @deprecated Use `factory.updateTypePredicateNode` or the factory supplied by your transformation context instead. */
7599    const updateTypePredicateNodeWithModifier: (node: TypePredicateNode, assertsModifier: AssertsKeyword | undefined, parameterName: Identifier | ThisTypeNode, type: TypeNode | undefined) => TypePredicateNode;
7600    /** @deprecated Use `factory.createTypeReferenceNode` or the factory supplied by your transformation context instead. */
7601    const createTypeReferenceNode: (typeName: string | EntityName, typeArguments?: readonly TypeNode[] | undefined) => TypeReferenceNode;
7602    /** @deprecated Use `factory.updateTypeReferenceNode` or the factory supplied by your transformation context instead. */
7603    const updateTypeReferenceNode: (node: TypeReferenceNode, typeName: EntityName, typeArguments: NodeArray<TypeNode> | undefined) => TypeReferenceNode;
7604    /** @deprecated Use `factory.createFunctionTypeNode` or the factory supplied by your transformation context instead. */
7605    const createFunctionTypeNode: (typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode) => FunctionTypeNode;
7606    /** @deprecated Use `factory.updateFunctionTypeNode` or the factory supplied by your transformation context instead. */
7607    const updateFunctionTypeNode: (node: FunctionTypeNode, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode) => FunctionTypeNode;
7608    /** @deprecated Use `factory.createConstructorTypeNode` or the factory supplied by your transformation context instead. */
7609    const createConstructorTypeNode: (typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode) => ConstructorTypeNode;
7610    /** @deprecated Use `factory.updateConstructorTypeNode` or the factory supplied by your transformation context instead. */
7611    const updateConstructorTypeNode: (node: ConstructorTypeNode, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode) => ConstructorTypeNode;
7612    /** @deprecated Use `factory.createTypeQueryNode` or the factory supplied by your transformation context instead. */
7613    const createTypeQueryNode: (exprName: EntityName, typeArguments?: readonly TypeNode[] | undefined) => TypeQueryNode;
7614    /** @deprecated Use `factory.updateTypeQueryNode` or the factory supplied by your transformation context instead. */
7615    const updateTypeQueryNode: (node: TypeQueryNode, exprName: EntityName, typeArguments?: readonly TypeNode[] | undefined) => TypeQueryNode;
7616    /** @deprecated Use `factory.createTypeLiteralNode` or the factory supplied by your transformation context instead. */
7617    const createTypeLiteralNode: (members: readonly TypeElement[] | undefined) => TypeLiteralNode;
7618    /** @deprecated Use `factory.updateTypeLiteralNode` or the factory supplied by your transformation context instead. */
7619    const updateTypeLiteralNode: (node: TypeLiteralNode, members: NodeArray<TypeElement>) => TypeLiteralNode;
7620    /** @deprecated Use `factory.createArrayTypeNode` or the factory supplied by your transformation context instead. */
7621    const createArrayTypeNode: (elementType: TypeNode) => ArrayTypeNode;
7622    /** @deprecated Use `factory.updateArrayTypeNode` or the factory supplied by your transformation context instead. */
7623    const updateArrayTypeNode: (node: ArrayTypeNode, elementType: TypeNode) => ArrayTypeNode;
7624    /** @deprecated Use `factory.createTupleTypeNode` or the factory supplied by your transformation context instead. */
7625    const createTupleTypeNode: (elements: readonly (TypeNode | NamedTupleMember)[]) => TupleTypeNode;
7626    /** @deprecated Use `factory.updateTupleTypeNode` or the factory supplied by your transformation context instead. */
7627    const updateTupleTypeNode: (node: TupleTypeNode, elements: readonly (TypeNode | NamedTupleMember)[]) => TupleTypeNode;
7628    /** @deprecated Use `factory.createOptionalTypeNode` or the factory supplied by your transformation context instead. */
7629    const createOptionalTypeNode: (type: TypeNode) => OptionalTypeNode;
7630    /** @deprecated Use `factory.updateOptionalTypeNode` or the factory supplied by your transformation context instead. */
7631    const updateOptionalTypeNode: (node: OptionalTypeNode, type: TypeNode) => OptionalTypeNode;
7632    /** @deprecated Use `factory.createRestTypeNode` or the factory supplied by your transformation context instead. */
7633    const createRestTypeNode: (type: TypeNode) => RestTypeNode;
7634    /** @deprecated Use `factory.updateRestTypeNode` or the factory supplied by your transformation context instead. */
7635    const updateRestTypeNode: (node: RestTypeNode, type: TypeNode) => RestTypeNode;
7636    /** @deprecated Use `factory.createUnionTypeNode` or the factory supplied by your transformation context instead. */
7637    const createUnionTypeNode: (types: readonly TypeNode[]) => UnionTypeNode;
7638    /** @deprecated Use `factory.updateUnionTypeNode` or the factory supplied by your transformation context instead. */
7639    const updateUnionTypeNode: (node: UnionTypeNode, types: NodeArray<TypeNode>) => UnionTypeNode;
7640    /** @deprecated Use `factory.createIntersectionTypeNode` or the factory supplied by your transformation context instead. */
7641    const createIntersectionTypeNode: (types: readonly TypeNode[]) => IntersectionTypeNode;
7642    /** @deprecated Use `factory.updateIntersectionTypeNode` or the factory supplied by your transformation context instead. */
7643    const updateIntersectionTypeNode: (node: IntersectionTypeNode, types: NodeArray<TypeNode>) => IntersectionTypeNode;
7644    /** @deprecated Use `factory.createConditionalTypeNode` or the factory supplied by your transformation context instead. */
7645    const createConditionalTypeNode: (checkType: TypeNode, extendsType: TypeNode, trueType: TypeNode, falseType: TypeNode) => ConditionalTypeNode;
7646    /** @deprecated Use `factory.updateConditionalTypeNode` or the factory supplied by your transformation context instead. */
7647    const updateConditionalTypeNode: (node: ConditionalTypeNode, checkType: TypeNode, extendsType: TypeNode, trueType: TypeNode, falseType: TypeNode) => ConditionalTypeNode;
7648    /** @deprecated Use `factory.createInferTypeNode` or the factory supplied by your transformation context instead. */
7649    const createInferTypeNode: (typeParameter: TypeParameterDeclaration) => InferTypeNode;
7650    /** @deprecated Use `factory.updateInferTypeNode` or the factory supplied by your transformation context instead. */
7651    const updateInferTypeNode: (node: InferTypeNode, typeParameter: TypeParameterDeclaration) => InferTypeNode;
7652    /** @deprecated Use `factory.createImportTypeNode` or the factory supplied by your transformation context instead. */
7653    const createImportTypeNode: {
7654        (argument: TypeNode, assertions?: ImportTypeAssertionContainer | undefined, qualifier?: EntityName | undefined, typeArguments?: readonly TypeNode[] | undefined, isTypeOf?: boolean | undefined): ImportTypeNode;
7655        (argument: TypeNode, assertions?: ImportTypeAssertionContainer | undefined, qualifier?: EntityName | undefined, typeArguments?: readonly TypeNode[] | undefined, isTypeOf?: boolean | undefined): ImportTypeNode;
7656        (argument: TypeNode, qualifier?: EntityName | undefined, typeArguments?: readonly TypeNode[] | undefined, isTypeOf?: boolean | undefined): ImportTypeNode;
7657    };
7658    /** @deprecated Use `factory.updateImportTypeNode` or the factory supplied by your transformation context instead. */
7659    const updateImportTypeNode: {
7660        (node: ImportTypeNode, argument: TypeNode, assertions: ImportTypeAssertionContainer | undefined, qualifier: EntityName | undefined, typeArguments: readonly TypeNode[] | undefined, isTypeOf?: boolean | undefined): ImportTypeNode;
7661        (node: ImportTypeNode, argument: TypeNode, qualifier: EntityName | undefined, typeArguments: readonly TypeNode[] | undefined, isTypeOf?: boolean | undefined): ImportTypeNode;
7662    };
7663    /** @deprecated Use `factory.createParenthesizedType` or the factory supplied by your transformation context instead. */
7664    const createParenthesizedType: (type: TypeNode) => ParenthesizedTypeNode;
7665    /** @deprecated Use `factory.updateParenthesizedType` or the factory supplied by your transformation context instead. */
7666    const updateParenthesizedType: (node: ParenthesizedTypeNode, type: TypeNode) => ParenthesizedTypeNode;
7667    /** @deprecated Use `factory.createThisTypeNode` or the factory supplied by your transformation context instead. */
7668    const createThisTypeNode: () => ThisTypeNode;
7669    /** @deprecated Use `factory.updateTypeOperatorNode` or the factory supplied by your transformation context instead. */
7670    const updateTypeOperatorNode: (node: TypeOperatorNode, type: TypeNode) => TypeOperatorNode;
7671    /** @deprecated Use `factory.createIndexedAccessTypeNode` or the factory supplied by your transformation context instead. */
7672    const createIndexedAccessTypeNode: (objectType: TypeNode, indexType: TypeNode) => IndexedAccessTypeNode;
7673    /** @deprecated Use `factory.updateIndexedAccessTypeNode` or the factory supplied by your transformation context instead. */
7674    const updateIndexedAccessTypeNode: (node: IndexedAccessTypeNode, objectType: TypeNode, indexType: TypeNode) => IndexedAccessTypeNode;
7675    /** @deprecated Use `factory.createMappedTypeNode` or the factory supplied by your transformation context instead. */
7676    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;
7677    /** @deprecated Use `factory.updateMappedTypeNode` or the factory supplied by your transformation context instead. */
7678    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;
7679    /** @deprecated Use `factory.createLiteralTypeNode` or the factory supplied by your transformation context instead. */
7680    const createLiteralTypeNode: (literal: LiteralExpression | BooleanLiteral | PrefixUnaryExpression | NullLiteral) => LiteralTypeNode;
7681    /** @deprecated Use `factory.updateLiteralTypeNode` or the factory supplied by your transformation context instead. */
7682    const updateLiteralTypeNode: (node: LiteralTypeNode, literal: LiteralExpression | BooleanLiteral | PrefixUnaryExpression | NullLiteral) => LiteralTypeNode;
7683    /** @deprecated Use `factory.createObjectBindingPattern` or the factory supplied by your transformation context instead. */
7684    const createObjectBindingPattern: (elements: readonly BindingElement[]) => ObjectBindingPattern;
7685    /** @deprecated Use `factory.updateObjectBindingPattern` or the factory supplied by your transformation context instead. */
7686    const updateObjectBindingPattern: (node: ObjectBindingPattern, elements: readonly BindingElement[]) => ObjectBindingPattern;
7687    /** @deprecated Use `factory.createArrayBindingPattern` or the factory supplied by your transformation context instead. */
7688    const createArrayBindingPattern: (elements: readonly ArrayBindingElement[]) => ArrayBindingPattern;
7689    /** @deprecated Use `factory.updateArrayBindingPattern` or the factory supplied by your transformation context instead. */
7690    const updateArrayBindingPattern: (node: ArrayBindingPattern, elements: readonly ArrayBindingElement[]) => ArrayBindingPattern;
7691    /** @deprecated Use `factory.createBindingElement` or the factory supplied by your transformation context instead. */
7692    const createBindingElement: (dotDotDotToken: DotDotDotToken | undefined, propertyName: string | PropertyName | undefined, name: string | BindingName, initializer?: Expression | undefined) => BindingElement;
7693    /** @deprecated Use `factory.updateBindingElement` or the factory supplied by your transformation context instead. */
7694    const updateBindingElement: (node: BindingElement, dotDotDotToken: DotDotDotToken | undefined, propertyName: PropertyName | undefined, name: BindingName, initializer: Expression | undefined) => BindingElement;
7695    /** @deprecated Use `factory.createArrayLiteralExpression` or the factory supplied by your transformation context instead. */
7696    const createArrayLiteral: (elements?: readonly Expression[] | undefined, multiLine?: boolean | undefined) => ArrayLiteralExpression;
7697    /** @deprecated Use `factory.updateArrayLiteralExpression` or the factory supplied by your transformation context instead. */
7698    const updateArrayLiteral: (node: ArrayLiteralExpression, elements: readonly Expression[]) => ArrayLiteralExpression;
7699    /** @deprecated Use `factory.createObjectLiteralExpression` or the factory supplied by your transformation context instead. */
7700    const createObjectLiteral: (properties?: readonly ObjectLiteralElementLike[] | undefined, multiLine?: boolean | undefined) => ObjectLiteralExpression;
7701    /** @deprecated Use `factory.updateObjectLiteralExpression` or the factory supplied by your transformation context instead. */
7702    const updateObjectLiteral: (node: ObjectLiteralExpression, properties: readonly ObjectLiteralElementLike[]) => ObjectLiteralExpression;
7703    /** @deprecated Use `factory.createPropertyAccessExpression` or the factory supplied by your transformation context instead. */
7704    const createPropertyAccess: (expression: Expression, name: string | MemberName) => PropertyAccessExpression;
7705    /** @deprecated Use `factory.updatePropertyAccessExpression` or the factory supplied by your transformation context instead. */
7706    const updatePropertyAccess: (node: PropertyAccessExpression, expression: Expression, name: MemberName) => PropertyAccessExpression;
7707    /** @deprecated Use `factory.createPropertyAccessChain` or the factory supplied by your transformation context instead. */
7708    const createPropertyAccessChain: (expression: Expression, questionDotToken: QuestionDotToken | undefined, name: string | MemberName) => PropertyAccessChain;
7709    /** @deprecated Use `factory.updatePropertyAccessChain` or the factory supplied by your transformation context instead. */
7710    const updatePropertyAccessChain: (node: PropertyAccessChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, name: MemberName) => PropertyAccessChain;
7711    /** @deprecated Use `factory.createElementAccessExpression` or the factory supplied by your transformation context instead. */
7712    const createElementAccess: (expression: Expression, index: number | Expression) => ElementAccessExpression;
7713    /** @deprecated Use `factory.updateElementAccessExpression` or the factory supplied by your transformation context instead. */
7714    const updateElementAccess: (node: ElementAccessExpression, expression: Expression, argumentExpression: Expression) => ElementAccessExpression;
7715    /** @deprecated Use `factory.createElementAccessChain` or the factory supplied by your transformation context instead. */
7716    const createElementAccessChain: (expression: Expression, questionDotToken: QuestionDotToken | undefined, index: number | Expression) => ElementAccessChain;
7717    /** @deprecated Use `factory.updateElementAccessChain` or the factory supplied by your transformation context instead. */
7718    const updateElementAccessChain: (node: ElementAccessChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, argumentExpression: Expression) => ElementAccessChain;
7719    /** @deprecated Use `factory.createCallExpression` or the factory supplied by your transformation context instead. */
7720    const createCall: (expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined) => CallExpression;
7721    /** @deprecated Use `factory.updateCallExpression` or the factory supplied by your transformation context instead. */
7722    const updateCall: (node: CallExpression, expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[]) => CallExpression;
7723    /** @deprecated Use `factory.createCallChain` or the factory supplied by your transformation context instead. */
7724    const createCallChain: (expression: Expression, questionDotToken: QuestionDotToken | undefined, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined) => CallChain;
7725    /** @deprecated Use `factory.updateCallChain` or the factory supplied by your transformation context instead. */
7726    const updateCallChain: (node: CallChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[]) => CallChain;
7727    /** @deprecated Use `factory.createNewExpression` or the factory supplied by your transformation context instead. */
7728    const createNew: (expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined) => NewExpression;
7729    /** @deprecated Use `factory.updateNewExpression` or the factory supplied by your transformation context instead. */
7730    const updateNew: (node: NewExpression, expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined) => NewExpression;
7731    /** @deprecated Use `factory.createTypeAssertion` or the factory supplied by your transformation context instead. */
7732    const createTypeAssertion: (type: TypeNode, expression: Expression) => TypeAssertion;
7733    /** @deprecated Use `factory.updateTypeAssertion` or the factory supplied by your transformation context instead. */
7734    const updateTypeAssertion: (node: TypeAssertion, type: TypeNode, expression: Expression) => TypeAssertion;
7735    /** @deprecated Use `factory.createParenthesizedExpression` or the factory supplied by your transformation context instead. */
7736    const createParen: (expression: Expression) => ParenthesizedExpression;
7737    /** @deprecated Use `factory.updateParenthesizedExpression` or the factory supplied by your transformation context instead. */
7738    const updateParen: (node: ParenthesizedExpression, expression: Expression) => ParenthesizedExpression;
7739    /** @deprecated Use `factory.createFunctionExpression` or the factory supplied by your transformation context instead. */
7740    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;
7741    /** @deprecated Use `factory.updateFunctionExpression` or the factory supplied by your transformation context instead. */
7742    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;
7743    /** @deprecated Use `factory.createDeleteExpression` or the factory supplied by your transformation context instead. */
7744    const createDelete: (expression: Expression) => DeleteExpression;
7745    /** @deprecated Use `factory.updateDeleteExpression` or the factory supplied by your transformation context instead. */
7746    const updateDelete: (node: DeleteExpression, expression: Expression) => DeleteExpression;
7747    /** @deprecated Use `factory.createTypeOfExpression` or the factory supplied by your transformation context instead. */
7748    const createTypeOf: (expression: Expression) => TypeOfExpression;
7749    /** @deprecated Use `factory.updateTypeOfExpression` or the factory supplied by your transformation context instead. */
7750    const updateTypeOf: (node: TypeOfExpression, expression: Expression) => TypeOfExpression;
7751    /** @deprecated Use `factory.createVoidExpression` or the factory supplied by your transformation context instead. */
7752    const createVoid: (expression: Expression) => VoidExpression;
7753    /** @deprecated Use `factory.updateVoidExpression` or the factory supplied by your transformation context instead. */
7754    const updateVoid: (node: VoidExpression, expression: Expression) => VoidExpression;
7755    /** @deprecated Use `factory.createAwaitExpression` or the factory supplied by your transformation context instead. */
7756    const createAwait: (expression: Expression) => AwaitExpression;
7757    /** @deprecated Use `factory.updateAwaitExpression` or the factory supplied by your transformation context instead. */
7758    const updateAwait: (node: AwaitExpression, expression: Expression) => AwaitExpression;
7759    /** @deprecated Use `factory.createPrefixExpression` or the factory supplied by your transformation context instead. */
7760    const createPrefix: (operator: PrefixUnaryOperator, operand: Expression) => PrefixUnaryExpression;
7761    /** @deprecated Use `factory.updatePrefixExpression` or the factory supplied by your transformation context instead. */
7762    const updatePrefix: (node: PrefixUnaryExpression, operand: Expression) => PrefixUnaryExpression;
7763    /** @deprecated Use `factory.createPostfixUnaryExpression` or the factory supplied by your transformation context instead. */
7764    const createPostfix: (operand: Expression, operator: PostfixUnaryOperator) => PostfixUnaryExpression;
7765    /** @deprecated Use `factory.updatePostfixUnaryExpression` or the factory supplied by your transformation context instead. */
7766    const updatePostfix: (node: PostfixUnaryExpression, operand: Expression) => PostfixUnaryExpression;
7767    /** @deprecated Use `factory.createBinaryExpression` or the factory supplied by your transformation context instead. */
7768    const createBinary: (left: Expression, operator: BinaryOperator | BinaryOperatorToken, right: Expression) => BinaryExpression;
7769    /** @deprecated Use `factory.updateConditionalExpression` or the factory supplied by your transformation context instead. */
7770    const updateConditional: (node: ConditionalExpression, condition: Expression, questionToken: QuestionToken, whenTrue: Expression, colonToken: ColonToken, whenFalse: Expression) => ConditionalExpression;
7771    /** @deprecated Use `factory.createTemplateExpression` or the factory supplied by your transformation context instead. */
7772    const createTemplateExpression: (head: TemplateHead, templateSpans: readonly TemplateSpan[]) => TemplateExpression;
7773    /** @deprecated Use `factory.updateTemplateExpression` or the factory supplied by your transformation context instead. */
7774    const updateTemplateExpression: (node: TemplateExpression, head: TemplateHead, templateSpans: readonly TemplateSpan[]) => TemplateExpression;
7775    /** @deprecated Use `factory.createTemplateHead` or the factory supplied by your transformation context instead. */
7776    const createTemplateHead: {
7777        (text: string, rawText?: string | undefined, templateFlags?: TokenFlags | undefined): TemplateHead;
7778        (text: string | undefined, rawText: string, templateFlags?: TokenFlags | undefined): TemplateHead;
7779    };
7780    /** @deprecated Use `factory.createTemplateMiddle` or the factory supplied by your transformation context instead. */
7781    const createTemplateMiddle: {
7782        (text: string, rawText?: string | undefined, templateFlags?: TokenFlags | undefined): TemplateMiddle;
7783        (text: string | undefined, rawText: string, templateFlags?: TokenFlags | undefined): TemplateMiddle;
7784    };
7785    /** @deprecated Use `factory.createTemplateTail` or the factory supplied by your transformation context instead. */
7786    const createTemplateTail: {
7787        (text: string, rawText?: string | undefined, templateFlags?: TokenFlags | undefined): TemplateTail;
7788        (text: string | undefined, rawText: string, templateFlags?: TokenFlags | undefined): TemplateTail;
7789    };
7790    /** @deprecated Use `factory.createNoSubstitutionTemplateLiteral` or the factory supplied by your transformation context instead. */
7791    const createNoSubstitutionTemplateLiteral: {
7792        (text: string, rawText?: string | undefined): NoSubstitutionTemplateLiteral;
7793        (text: string | undefined, rawText: string): NoSubstitutionTemplateLiteral;
7794    };
7795    /** @deprecated Use `factory.updateYieldExpression` or the factory supplied by your transformation context instead. */
7796    const updateYield: (node: YieldExpression, asteriskToken: AsteriskToken | undefined, expression: Expression | undefined) => YieldExpression;
7797    /** @deprecated Use `factory.createSpreadExpression` or the factory supplied by your transformation context instead. */
7798    const createSpread: (expression: Expression) => SpreadElement;
7799    /** @deprecated Use `factory.updateSpreadExpression` or the factory supplied by your transformation context instead. */
7800    const updateSpread: (node: SpreadElement, expression: Expression) => SpreadElement;
7801    /** @deprecated Use `factory.createOmittedExpression` or the factory supplied by your transformation context instead. */
7802    const createOmittedExpression: () => OmittedExpression;
7803    /** @deprecated Use `factory.createAsExpression` or the factory supplied by your transformation context instead. */
7804    const createAsExpression: (expression: Expression, type: TypeNode) => AsExpression;
7805    /** @deprecated Use `factory.updateAsExpression` or the factory supplied by your transformation context instead. */
7806    const updateAsExpression: (node: AsExpression, expression: Expression, type: TypeNode) => AsExpression;
7807    /** @deprecated Use `factory.createNonNullExpression` or the factory supplied by your transformation context instead. */
7808    const createNonNullExpression: (expression: Expression) => NonNullExpression;
7809    /** @deprecated Use `factory.updateNonNullExpression` or the factory supplied by your transformation context instead. */
7810    const updateNonNullExpression: (node: NonNullExpression, expression: Expression) => NonNullExpression;
7811    /** @deprecated Use `factory.createNonNullChain` or the factory supplied by your transformation context instead. */
7812    const createNonNullChain: (expression: Expression) => NonNullChain;
7813    /** @deprecated Use `factory.updateNonNullChain` or the factory supplied by your transformation context instead. */
7814    const updateNonNullChain: (node: NonNullChain, expression: Expression) => NonNullChain;
7815    /** @deprecated Use `factory.createMetaProperty` or the factory supplied by your transformation context instead. */
7816    const createMetaProperty: (keywordToken: SyntaxKind.ImportKeyword | SyntaxKind.NewKeyword, name: Identifier) => MetaProperty;
7817    /** @deprecated Use `factory.updateMetaProperty` or the factory supplied by your transformation context instead. */
7818    const updateMetaProperty: (node: MetaProperty, name: Identifier) => MetaProperty;
7819    /** @deprecated Use `factory.createTemplateSpan` or the factory supplied by your transformation context instead. */
7820    const createTemplateSpan: (expression: Expression, literal: TemplateMiddle | TemplateTail) => TemplateSpan;
7821    /** @deprecated Use `factory.updateTemplateSpan` or the factory supplied by your transformation context instead. */
7822    const updateTemplateSpan: (node: TemplateSpan, expression: Expression, literal: TemplateMiddle | TemplateTail) => TemplateSpan;
7823    /** @deprecated Use `factory.createSemicolonClassElement` or the factory supplied by your transformation context instead. */
7824    const createSemicolonClassElement: () => SemicolonClassElement;
7825    /** @deprecated Use `factory.createBlock` or the factory supplied by your transformation context instead. */
7826    const createBlock: (statements: readonly Statement[], multiLine?: boolean | undefined) => Block;
7827    /** @deprecated Use `factory.updateBlock` or the factory supplied by your transformation context instead. */
7828    const updateBlock: (node: Block, statements: readonly Statement[]) => Block;
7829    /** @deprecated Use `factory.createVariableStatement` or the factory supplied by your transformation context instead. */
7830    const createVariableStatement: (modifiers: readonly Modifier[] | undefined, declarationList: VariableDeclarationList | readonly VariableDeclaration[]) => VariableStatement;
7831    /** @deprecated Use `factory.updateVariableStatement` or the factory supplied by your transformation context instead. */
7832    const updateVariableStatement: (node: VariableStatement, modifiers: readonly Modifier[] | undefined, declarationList: VariableDeclarationList) => VariableStatement;
7833    /** @deprecated Use `factory.createEmptyStatement` or the factory supplied by your transformation context instead. */
7834    const createEmptyStatement: () => EmptyStatement;
7835    /** @deprecated Use `factory.createExpressionStatement` or the factory supplied by your transformation context instead. */
7836    const createExpressionStatement: (expression: Expression) => ExpressionStatement;
7837    /** @deprecated Use `factory.updateExpressionStatement` or the factory supplied by your transformation context instead. */
7838    const updateExpressionStatement: (node: ExpressionStatement, expression: Expression) => ExpressionStatement;
7839    /** @deprecated Use `factory.createExpressionStatement` or the factory supplied by your transformation context instead. */
7840    const createStatement: (expression: Expression) => ExpressionStatement;
7841    /** @deprecated Use `factory.updateExpressionStatement` or the factory supplied by your transformation context instead. */
7842    const updateStatement: (node: ExpressionStatement, expression: Expression) => ExpressionStatement;
7843    /** @deprecated Use `factory.createIfStatement` or the factory supplied by your transformation context instead. */
7844    const createIf: (expression: Expression, thenStatement: Statement, elseStatement?: Statement | undefined) => IfStatement;
7845    /** @deprecated Use `factory.updateIfStatement` or the factory supplied by your transformation context instead. */
7846    const updateIf: (node: IfStatement, expression: Expression, thenStatement: Statement, elseStatement: Statement | undefined) => IfStatement;
7847    /** @deprecated Use `factory.createDoStatement` or the factory supplied by your transformation context instead. */
7848    const createDo: (statement: Statement, expression: Expression) => DoStatement;
7849    /** @deprecated Use `factory.updateDoStatement` or the factory supplied by your transformation context instead. */
7850    const updateDo: (node: DoStatement, statement: Statement, expression: Expression) => DoStatement;
7851    /** @deprecated Use `factory.createWhileStatement` or the factory supplied by your transformation context instead. */
7852    const createWhile: (expression: Expression, statement: Statement) => WhileStatement;
7853    /** @deprecated Use `factory.updateWhileStatement` or the factory supplied by your transformation context instead. */
7854    const updateWhile: (node: WhileStatement, expression: Expression, statement: Statement) => WhileStatement;
7855    /** @deprecated Use `factory.createForStatement` or the factory supplied by your transformation context instead. */
7856    const createFor: (initializer: ForInitializer | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement) => ForStatement;
7857    /** @deprecated Use `factory.updateForStatement` or the factory supplied by your transformation context instead. */
7858    const updateFor: (node: ForStatement, initializer: ForInitializer | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement) => ForStatement;
7859    /** @deprecated Use `factory.createForInStatement` or the factory supplied by your transformation context instead. */
7860    const createForIn: (initializer: ForInitializer, expression: Expression, statement: Statement) => ForInStatement;
7861    /** @deprecated Use `factory.updateForInStatement` or the factory supplied by your transformation context instead. */
7862    const updateForIn: (node: ForInStatement, initializer: ForInitializer, expression: Expression, statement: Statement) => ForInStatement;
7863    /** @deprecated Use `factory.createForOfStatement` or the factory supplied by your transformation context instead. */
7864    const createForOf: (awaitModifier: AwaitKeyword | undefined, initializer: ForInitializer, expression: Expression, statement: Statement) => ForOfStatement;
7865    /** @deprecated Use `factory.updateForOfStatement` or the factory supplied by your transformation context instead. */
7866    const updateForOf: (node: ForOfStatement, awaitModifier: AwaitKeyword | undefined, initializer: ForInitializer, expression: Expression, statement: Statement) => ForOfStatement;
7867    /** @deprecated Use `factory.createContinueStatement` or the factory supplied by your transformation context instead. */
7868    const createContinue: (label?: string | Identifier | undefined) => ContinueStatement;
7869    /** @deprecated Use `factory.updateContinueStatement` or the factory supplied by your transformation context instead. */
7870    const updateContinue: (node: ContinueStatement, label: Identifier | undefined) => ContinueStatement;
7871    /** @deprecated Use `factory.createBreakStatement` or the factory supplied by your transformation context instead. */
7872    const createBreak: (label?: string | Identifier | undefined) => BreakStatement;
7873    /** @deprecated Use `factory.updateBreakStatement` or the factory supplied by your transformation context instead. */
7874    const updateBreak: (node: BreakStatement, label: Identifier | undefined) => BreakStatement;
7875    /** @deprecated Use `factory.createReturnStatement` or the factory supplied by your transformation context instead. */
7876    const createReturn: (expression?: Expression | undefined) => ReturnStatement;
7877    /** @deprecated Use `factory.updateReturnStatement` or the factory supplied by your transformation context instead. */
7878    const updateReturn: (node: ReturnStatement, expression: Expression | undefined) => ReturnStatement;
7879    /** @deprecated Use `factory.createWithStatement` or the factory supplied by your transformation context instead. */
7880    const createWith: (expression: Expression, statement: Statement) => WithStatement;
7881    /** @deprecated Use `factory.updateWithStatement` or the factory supplied by your transformation context instead. */
7882    const updateWith: (node: WithStatement, expression: Expression, statement: Statement) => WithStatement;
7883    /** @deprecated Use `factory.createSwitchStatement` or the factory supplied by your transformation context instead. */
7884    const createSwitch: (expression: Expression, caseBlock: CaseBlock) => SwitchStatement;
7885    /** @deprecated Use `factory.updateSwitchStatement` or the factory supplied by your transformation context instead. */
7886    const updateSwitch: (node: SwitchStatement, expression: Expression, caseBlock: CaseBlock) => SwitchStatement;
7887    /** @deprecated Use `factory.createLabelStatement` or the factory supplied by your transformation context instead. */
7888    const createLabel: (label: string | Identifier, statement: Statement) => LabeledStatement;
7889    /** @deprecated Use `factory.updateLabelStatement` or the factory supplied by your transformation context instead. */
7890    const updateLabel: (node: LabeledStatement, label: Identifier, statement: Statement) => LabeledStatement;
7891    /** @deprecated Use `factory.createThrowStatement` or the factory supplied by your transformation context instead. */
7892    const createThrow: (expression: Expression) => ThrowStatement;
7893    /** @deprecated Use `factory.updateThrowStatement` or the factory supplied by your transformation context instead. */
7894    const updateThrow: (node: ThrowStatement, expression: Expression) => ThrowStatement;
7895    /** @deprecated Use `factory.createTryStatement` or the factory supplied by your transformation context instead. */
7896    const createTry: (tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined) => TryStatement;
7897    /** @deprecated Use `factory.updateTryStatement` or the factory supplied by your transformation context instead. */
7898    const updateTry: (node: TryStatement, tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined) => TryStatement;
7899    /** @deprecated Use `factory.createDebuggerStatement` or the factory supplied by your transformation context instead. */
7900    const createDebuggerStatement: () => DebuggerStatement;
7901    /** @deprecated Use `factory.createVariableDeclarationList` or the factory supplied by your transformation context instead. */
7902    const createVariableDeclarationList: (declarations: readonly VariableDeclaration[], flags?: NodeFlags | undefined) => VariableDeclarationList;
7903    /** @deprecated Use `factory.updateVariableDeclarationList` or the factory supplied by your transformation context instead. */
7904    const updateVariableDeclarationList: (node: VariableDeclarationList, declarations: readonly VariableDeclaration[]) => VariableDeclarationList;
7905    /** @deprecated Use `factory.createFunctionDeclaration` or the factory supplied by your transformation context instead. */
7906    const createFunctionDeclaration: {
7907        (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;
7908        (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;
7909    };
7910    /** @deprecated Use `factory.updateFunctionDeclaration` or the factory supplied by your transformation context instead. */
7911    const updateFunctionDeclaration: {
7912        (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;
7913        (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;
7914    };
7915    /** @deprecated Use `factory.createClassDeclaration` or the factory supplied by your transformation context instead. */
7916    const createClassDeclaration: {
7917        (modifiers: readonly ModifierLike[] | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassDeclaration;
7918        (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassDeclaration;
7919    };
7920    /** @deprecated Use `factory.updateClassDeclaration` or the factory supplied by your transformation context instead. */
7921    const updateClassDeclaration: {
7922        (node: ClassDeclaration, modifiers: readonly ModifierLike[] | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassDeclaration;
7923        (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;
7924    };
7925    /** @deprecated Use `factory.createInterfaceDeclaration` or the factory supplied by your transformation context instead. */
7926    const createInterfaceDeclaration: {
7927        (modifiers: readonly Modifier[] | undefined, name: string | Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly TypeElement[]): InterfaceDeclaration;
7928        (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly TypeElement[]): InterfaceDeclaration;
7929    };
7930    /** @deprecated Use `factory.updateInterfaceDeclaration` or the factory supplied by your transformation context instead. */
7931    const updateInterfaceDeclaration: {
7932        (node: InterfaceDeclaration, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly TypeElement[]): InterfaceDeclaration;
7933        (node: InterfaceDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly TypeElement[]): InterfaceDeclaration;
7934    };
7935    /** @deprecated Use `factory.createTypeAliasDeclaration` or the factory supplied by your transformation context instead. */
7936    const createTypeAliasDeclaration: {
7937        (modifiers: readonly Modifier[] | undefined, name: string | Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration;
7938        (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration;
7939    };
7940    /** @deprecated Use `factory.updateTypeAliasDeclaration` or the factory supplied by your transformation context instead. */
7941    const updateTypeAliasDeclaration: {
7942        (node: TypeAliasDeclaration, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration;
7943        (node: TypeAliasDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration;
7944    };
7945    /** @deprecated Use `factory.createEnumDeclaration` or the factory supplied by your transformation context instead. */
7946    const createEnumDeclaration: {
7947        (modifiers: readonly Modifier[] | undefined, name: string | Identifier, members: readonly EnumMember[]): EnumDeclaration;
7948        (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, members: readonly EnumMember[]): EnumDeclaration;
7949    };
7950    /** @deprecated Use `factory.updateEnumDeclaration` or the factory supplied by your transformation context instead. */
7951    const updateEnumDeclaration: {
7952        (node: EnumDeclaration, modifiers: readonly Modifier[] | undefined, name: Identifier, members: readonly EnumMember[]): EnumDeclaration;
7953        (node: EnumDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, members: readonly EnumMember[]): EnumDeclaration;
7954    };
7955    /** @deprecated Use `factory.createModuleDeclaration` or the factory supplied by your transformation context instead. */
7956    const createModuleDeclaration: {
7957        (modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined, flags?: NodeFlags | undefined): ModuleDeclaration;
7958        (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined, flags?: NodeFlags | undefined): ModuleDeclaration;
7959    };
7960    /** @deprecated Use `factory.updateModuleDeclaration` or the factory supplied by your transformation context instead. */
7961    const updateModuleDeclaration: {
7962        (node: ModuleDeclaration, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined): ModuleDeclaration;
7963        (node: ModuleDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined): ModuleDeclaration;
7964    };
7965    /** @deprecated Use `factory.createModuleBlock` or the factory supplied by your transformation context instead. */
7966    const createModuleBlock: (statements: readonly Statement[]) => ModuleBlock;
7967    /** @deprecated Use `factory.updateModuleBlock` or the factory supplied by your transformation context instead. */
7968    const updateModuleBlock: (node: ModuleBlock, statements: readonly Statement[]) => ModuleBlock;
7969    /** @deprecated Use `factory.createCaseBlock` or the factory supplied by your transformation context instead. */
7970    const createCaseBlock: (clauses: readonly CaseOrDefaultClause[]) => CaseBlock;
7971    /** @deprecated Use `factory.updateCaseBlock` or the factory supplied by your transformation context instead. */
7972    const updateCaseBlock: (node: CaseBlock, clauses: readonly CaseOrDefaultClause[]) => CaseBlock;
7973    /** @deprecated Use `factory.createNamespaceExportDeclaration` or the factory supplied by your transformation context instead. */
7974    const createNamespaceExportDeclaration: (name: string | Identifier) => NamespaceExportDeclaration;
7975    /** @deprecated Use `factory.updateNamespaceExportDeclaration` or the factory supplied by your transformation context instead. */
7976    const updateNamespaceExportDeclaration: (node: NamespaceExportDeclaration, name: Identifier) => NamespaceExportDeclaration;
7977    /** @deprecated Use `factory.createImportEqualsDeclaration` or the factory supplied by your transformation context instead. */
7978    const createImportEqualsDeclaration: {
7979        (modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: string | Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration;
7980        (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: string | Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration;
7981    };
7982    /** @deprecated Use `factory.updateImportEqualsDeclaration` or the factory supplied by your transformation context instead. */
7983    const updateImportEqualsDeclaration: {
7984        (node: ImportEqualsDeclaration, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration;
7985        (node: ImportEqualsDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration;
7986    };
7987    /** @deprecated Use `factory.createImportDeclaration` or the factory supplied by your transformation context instead. */
7988    const createImportDeclaration: {
7989        (modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause?: AssertClause | undefined): ImportDeclaration;
7990        (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause?: AssertClause | undefined): ImportDeclaration;
7991    };
7992    /** @deprecated Use `factory.updateImportDeclaration` or the factory supplied by your transformation context instead. */
7993    const updateImportDeclaration: {
7994        (node: ImportDeclaration, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration;
7995        (node: ImportDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration;
7996    };
7997    /** @deprecated Use `factory.createNamespaceImport` or the factory supplied by your transformation context instead. */
7998    const createNamespaceImport: (name: Identifier) => NamespaceImport;
7999    /** @deprecated Use `factory.updateNamespaceImport` or the factory supplied by your transformation context instead. */
8000    const updateNamespaceImport: (node: NamespaceImport, name: Identifier) => NamespaceImport;
8001    /** @deprecated Use `factory.createNamedImports` or the factory supplied by your transformation context instead. */
8002    const createNamedImports: (elements: readonly ImportSpecifier[]) => NamedImports;
8003    /** @deprecated Use `factory.updateNamedImports` or the factory supplied by your transformation context instead. */
8004    const updateNamedImports: (node: NamedImports, elements: readonly ImportSpecifier[]) => NamedImports;
8005    /** @deprecated Use `factory.createImportSpecifier` or the factory supplied by your transformation context instead. */
8006    const createImportSpecifier: (isTypeOnly: boolean, propertyName: Identifier | undefined, name: Identifier) => ImportSpecifier;
8007    /** @deprecated Use `factory.updateImportSpecifier` or the factory supplied by your transformation context instead. */
8008    const updateImportSpecifier: (node: ImportSpecifier, isTypeOnly: boolean, propertyName: Identifier | undefined, name: Identifier) => ImportSpecifier;
8009    /** @deprecated Use `factory.createExportAssignment` or the factory supplied by your transformation context instead. */
8010    const createExportAssignment: {
8011        (modifiers: readonly Modifier[] | undefined, isExportEquals: boolean | undefined, expression: Expression): ExportAssignment;
8012        (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isExportEquals: boolean | undefined, expression: Expression): ExportAssignment;
8013    };
8014    /** @deprecated Use `factory.updateExportAssignment` or the factory supplied by your transformation context instead. */
8015    const updateExportAssignment: {
8016        (node: ExportAssignment, modifiers: readonly Modifier[] | undefined, expression: Expression): ExportAssignment;
8017        (node: ExportAssignment, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, expression: Expression): ExportAssignment;
8018    };
8019    /** @deprecated Use `factory.createNamedExports` or the factory supplied by your transformation context instead. */
8020    const createNamedExports: (elements: readonly ExportSpecifier[]) => NamedExports;
8021    /** @deprecated Use `factory.updateNamedExports` or the factory supplied by your transformation context instead. */
8022    const updateNamedExports: (node: NamedExports, elements: readonly ExportSpecifier[]) => NamedExports;
8023    /** @deprecated Use `factory.createExportSpecifier` or the factory supplied by your transformation context instead. */
8024    const createExportSpecifier: (isTypeOnly: boolean, propertyName: string | Identifier | undefined, name: string | Identifier) => ExportSpecifier;
8025    /** @deprecated Use `factory.updateExportSpecifier` or the factory supplied by your transformation context instead. */
8026    const updateExportSpecifier: (node: ExportSpecifier, isTypeOnly: boolean, propertyName: Identifier | undefined, name: Identifier) => ExportSpecifier;
8027    /** @deprecated Use `factory.createExternalModuleReference` or the factory supplied by your transformation context instead. */
8028    const createExternalModuleReference: (expression: Expression) => ExternalModuleReference;
8029    /** @deprecated Use `factory.updateExternalModuleReference` or the factory supplied by your transformation context instead. */
8030    const updateExternalModuleReference: (node: ExternalModuleReference, expression: Expression) => ExternalModuleReference;
8031    /** @deprecated Use `factory.createJSDocTypeExpression` or the factory supplied by your transformation context instead. */
8032    const createJSDocTypeExpression: (type: TypeNode) => JSDocTypeExpression;
8033    /** @deprecated Use `factory.createJSDocTypeTag` or the factory supplied by your transformation context instead. */
8034    const createJSDocTypeTag: (tagName: Identifier | undefined, typeExpression: JSDocTypeExpression, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocTypeTag;
8035    /** @deprecated Use `factory.createJSDocReturnTag` or the factory supplied by your transformation context instead. */
8036    const createJSDocReturnTag: (tagName: Identifier | undefined, typeExpression?: JSDocTypeExpression | undefined, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocReturnTag;
8037    /** @deprecated Use `factory.createJSDocThisTag` or the factory supplied by your transformation context instead. */
8038    const createJSDocThisTag: (tagName: Identifier | undefined, typeExpression: JSDocTypeExpression, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocThisTag;
8039    /** @deprecated Use `factory.createJSDocComment` or the factory supplied by your transformation context instead. */
8040    const createJSDocComment: (comment?: string | NodeArray<JSDocComment> | undefined, tags?: readonly JSDocTag[] | undefined) => JSDoc;
8041    /** @deprecated Use `factory.createJSDocParameterTag` or the factory supplied by your transformation context instead. */
8042    const createJSDocParameterTag: (tagName: Identifier | undefined, name: EntityName, isBracketed: boolean, typeExpression?: JSDocTypeExpression | undefined, isNameFirst?: boolean | undefined, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocParameterTag;
8043    /** @deprecated Use `factory.createJSDocClassTag` or the factory supplied by your transformation context instead. */
8044    const createJSDocClassTag: (tagName: Identifier | undefined, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocClassTag;
8045    /** @deprecated Use `factory.createJSDocAugmentsTag` or the factory supplied by your transformation context instead. */
8046    const createJSDocAugmentsTag: (tagName: Identifier | undefined, className: ExpressionWithTypeArguments & {
8047        readonly expression: Identifier | PropertyAccessEntityNameExpression;
8048    }, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocAugmentsTag;
8049    /** @deprecated Use `factory.createJSDocEnumTag` or the factory supplied by your transformation context instead. */
8050    const createJSDocEnumTag: (tagName: Identifier | undefined, typeExpression: JSDocTypeExpression, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocEnumTag;
8051    /** @deprecated Use `factory.createJSDocTemplateTag` or the factory supplied by your transformation context instead. */
8052    const createJSDocTemplateTag: (tagName: Identifier | undefined, constraint: JSDocTypeExpression | undefined, typeParameters: readonly TypeParameterDeclaration[], comment?: string | NodeArray<JSDocComment> | undefined) => JSDocTemplateTag;
8053    /** @deprecated Use `factory.createJSDocTypedefTag` or the factory supplied by your transformation context instead. */
8054    const createJSDocTypedefTag: (tagName: Identifier | undefined, typeExpression?: JSDocTypeLiteral | JSDocTypeExpression | undefined, fullName?: Identifier | JSDocNamespaceDeclaration | undefined, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocTypedefTag;
8055    /** @deprecated Use `factory.createJSDocCallbackTag` or the factory supplied by your transformation context instead. */
8056    const createJSDocCallbackTag: (tagName: Identifier | undefined, typeExpression: JSDocSignature, fullName?: Identifier | JSDocNamespaceDeclaration | undefined, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocCallbackTag;
8057    /** @deprecated Use `factory.createJSDocSignature` or the factory supplied by your transformation context instead. */
8058    const createJSDocSignature: (typeParameters: readonly JSDocTemplateTag[] | undefined, parameters: readonly JSDocParameterTag[], type?: JSDocReturnTag | undefined) => JSDocSignature;
8059    /** @deprecated Use `factory.createJSDocPropertyTag` or the factory supplied by your transformation context instead. */
8060    const createJSDocPropertyTag: (tagName: Identifier | undefined, name: EntityName, isBracketed: boolean, typeExpression?: JSDocTypeExpression | undefined, isNameFirst?: boolean | undefined, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocPropertyTag;
8061    /** @deprecated Use `factory.createJSDocTypeLiteral` or the factory supplied by your transformation context instead. */
8062    const createJSDocTypeLiteral: (jsDocPropertyTags?: readonly JSDocPropertyLikeTag[] | undefined, isArrayType?: boolean | undefined) => JSDocTypeLiteral;
8063    /** @deprecated Use `factory.createJSDocImplementsTag` or the factory supplied by your transformation context instead. */
8064    const createJSDocImplementsTag: (tagName: Identifier | undefined, className: ExpressionWithTypeArguments & {
8065        readonly expression: Identifier | PropertyAccessEntityNameExpression;
8066    }, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocImplementsTag;
8067    /** @deprecated Use `factory.createJSDocAuthorTag` or the factory supplied by your transformation context instead. */
8068    const createJSDocAuthorTag: (tagName: Identifier | undefined, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocAuthorTag;
8069    /** @deprecated Use `factory.createJSDocPublicTag` or the factory supplied by your transformation context instead. */
8070    const createJSDocPublicTag: (tagName: Identifier | undefined, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocPublicTag;
8071    /** @deprecated Use `factory.createJSDocPrivateTag` or the factory supplied by your transformation context instead. */
8072    const createJSDocPrivateTag: (tagName: Identifier | undefined, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocPrivateTag;
8073    /** @deprecated Use `factory.createJSDocProtectedTag` or the factory supplied by your transformation context instead. */
8074    const createJSDocProtectedTag: (tagName: Identifier | undefined, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocProtectedTag;
8075    /** @deprecated Use `factory.createJSDocReadonlyTag` or the factory supplied by your transformation context instead. */
8076    const createJSDocReadonlyTag: (tagName: Identifier | undefined, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocReadonlyTag;
8077    /** @deprecated Use `factory.createJSDocUnknownTag` or the factory supplied by your transformation context instead. */
8078    const createJSDocTag: (tagName: Identifier, comment?: string | NodeArray<JSDocComment> | undefined) => JSDocUnknownTag;
8079    /** @deprecated Use `factory.createJsxElement` or the factory supplied by your transformation context instead. */
8080    const createJsxElement: (openingElement: JsxOpeningElement, children: readonly JsxChild[], closingElement: JsxClosingElement) => JsxElement;
8081    /** @deprecated Use `factory.updateJsxElement` or the factory supplied by your transformation context instead. */
8082    const updateJsxElement: (node: JsxElement, openingElement: JsxOpeningElement, children: readonly JsxChild[], closingElement: JsxClosingElement) => JsxElement;
8083    /** @deprecated Use `factory.createJsxSelfClosingElement` or the factory supplied by your transformation context instead. */
8084    const createJsxSelfClosingElement: (tagName: JsxTagNameExpression, typeArguments: readonly TypeNode[] | undefined, attributes: JsxAttributes) => JsxSelfClosingElement;
8085    /** @deprecated Use `factory.updateJsxSelfClosingElement` or the factory supplied by your transformation context instead. */
8086    const updateJsxSelfClosingElement: (node: JsxSelfClosingElement, tagName: JsxTagNameExpression, typeArguments: readonly TypeNode[] | undefined, attributes: JsxAttributes) => JsxSelfClosingElement;
8087    /** @deprecated Use `factory.createJsxOpeningElement` or the factory supplied by your transformation context instead. */
8088    const createJsxOpeningElement: (tagName: JsxTagNameExpression, typeArguments: readonly TypeNode[] | undefined, attributes: JsxAttributes) => JsxOpeningElement;
8089    /** @deprecated Use `factory.updateJsxOpeningElement` or the factory supplied by your transformation context instead. */
8090    const updateJsxOpeningElement: (node: JsxOpeningElement, tagName: JsxTagNameExpression, typeArguments: readonly TypeNode[] | undefined, attributes: JsxAttributes) => JsxOpeningElement;
8091    /** @deprecated Use `factory.createJsxClosingElement` or the factory supplied by your transformation context instead. */
8092    const createJsxClosingElement: (tagName: JsxTagNameExpression) => JsxClosingElement;
8093    /** @deprecated Use `factory.updateJsxClosingElement` or the factory supplied by your transformation context instead. */
8094    const updateJsxClosingElement: (node: JsxClosingElement, tagName: JsxTagNameExpression) => JsxClosingElement;
8095    /** @deprecated Use `factory.createJsxFragment` or the factory supplied by your transformation context instead. */
8096    const createJsxFragment: (openingFragment: JsxOpeningFragment, children: readonly JsxChild[], closingFragment: JsxClosingFragment) => JsxFragment;
8097    /** @deprecated Use `factory.createJsxText` or the factory supplied by your transformation context instead. */
8098    const createJsxText: (text: string, containsOnlyTriviaWhiteSpaces?: boolean | undefined) => JsxText;
8099    /** @deprecated Use `factory.updateJsxText` or the factory supplied by your transformation context instead. */
8100    const updateJsxText: (node: JsxText, text: string, containsOnlyTriviaWhiteSpaces?: boolean | undefined) => JsxText;
8101    /** @deprecated Use `factory.createJsxOpeningFragment` or the factory supplied by your transformation context instead. */
8102    const createJsxOpeningFragment: () => JsxOpeningFragment;
8103    /** @deprecated Use `factory.createJsxJsxClosingFragment` or the factory supplied by your transformation context instead. */
8104    const createJsxJsxClosingFragment: () => JsxClosingFragment;
8105    /** @deprecated Use `factory.updateJsxFragment` or the factory supplied by your transformation context instead. */
8106    const updateJsxFragment: (node: JsxFragment, openingFragment: JsxOpeningFragment, children: readonly JsxChild[], closingFragment: JsxClosingFragment) => JsxFragment;
8107    /** @deprecated Use `factory.createJsxAttribute` or the factory supplied by your transformation context instead. */
8108    const createJsxAttribute: (name: Identifier, initializer: JsxAttributeValue | undefined) => JsxAttribute;
8109    /** @deprecated Use `factory.updateJsxAttribute` or the factory supplied by your transformation context instead. */
8110    const updateJsxAttribute: (node: JsxAttribute, name: Identifier, initializer: JsxAttributeValue | undefined) => JsxAttribute;
8111    /** @deprecated Use `factory.createJsxAttributes` or the factory supplied by your transformation context instead. */
8112    const createJsxAttributes: (properties: readonly JsxAttributeLike[]) => JsxAttributes;
8113    /** @deprecated Use `factory.updateJsxAttributes` or the factory supplied by your transformation context instead. */
8114    const updateJsxAttributes: (node: JsxAttributes, properties: readonly JsxAttributeLike[]) => JsxAttributes;
8115    /** @deprecated Use `factory.createJsxSpreadAttribute` or the factory supplied by your transformation context instead. */
8116    const createJsxSpreadAttribute: (expression: Expression) => JsxSpreadAttribute;
8117    /** @deprecated Use `factory.updateJsxSpreadAttribute` or the factory supplied by your transformation context instead. */
8118    const updateJsxSpreadAttribute: (node: JsxSpreadAttribute, expression: Expression) => JsxSpreadAttribute;
8119    /** @deprecated Use `factory.createJsxExpression` or the factory supplied by your transformation context instead. */
8120    const createJsxExpression: (dotDotDotToken: DotDotDotToken | undefined, expression: Expression | undefined) => JsxExpression;
8121    /** @deprecated Use `factory.updateJsxExpression` or the factory supplied by your transformation context instead. */
8122    const updateJsxExpression: (node: JsxExpression, expression: Expression | undefined) => JsxExpression;
8123    /** @deprecated Use `factory.createCaseClause` or the factory supplied by your transformation context instead. */
8124    const createCaseClause: (expression: Expression, statements: readonly Statement[]) => CaseClause;
8125    /** @deprecated Use `factory.updateCaseClause` or the factory supplied by your transformation context instead. */
8126    const updateCaseClause: (node: CaseClause, expression: Expression, statements: readonly Statement[]) => CaseClause;
8127    /** @deprecated Use `factory.createDefaultClause` or the factory supplied by your transformation context instead. */
8128    const createDefaultClause: (statements: readonly Statement[]) => DefaultClause;
8129    /** @deprecated Use `factory.updateDefaultClause` or the factory supplied by your transformation context instead. */
8130    const updateDefaultClause: (node: DefaultClause, statements: readonly Statement[]) => DefaultClause;
8131    /** @deprecated Use `factory.createHeritageClause` or the factory supplied by your transformation context instead. */
8132    const createHeritageClause: (token: SyntaxKind.ExtendsKeyword | SyntaxKind.ImplementsKeyword, types: readonly ExpressionWithTypeArguments[]) => HeritageClause;
8133    /** @deprecated Use `factory.updateHeritageClause` or the factory supplied by your transformation context instead. */
8134    const updateHeritageClause: (node: HeritageClause, types: readonly ExpressionWithTypeArguments[]) => HeritageClause;
8135    /** @deprecated Use `factory.createCatchClause` or the factory supplied by your transformation context instead. */
8136    const createCatchClause: (variableDeclaration: string | VariableDeclaration | BindingName | undefined, block: Block) => CatchClause;
8137    /** @deprecated Use `factory.updateCatchClause` or the factory supplied by your transformation context instead. */
8138    const updateCatchClause: (node: CatchClause, variableDeclaration: VariableDeclaration | undefined, block: Block) => CatchClause;
8139    /** @deprecated Use `factory.createPropertyAssignment` or the factory supplied by your transformation context instead. */
8140    const createPropertyAssignment: (name: string | PropertyName, initializer: Expression) => PropertyAssignment;
8141    /** @deprecated Use `factory.updatePropertyAssignment` or the factory supplied by your transformation context instead. */
8142    const updatePropertyAssignment: (node: PropertyAssignment, name: PropertyName, initializer: Expression) => PropertyAssignment;
8143    /** @deprecated Use `factory.createShorthandPropertyAssignment` or the factory supplied by your transformation context instead. */
8144    const createShorthandPropertyAssignment: (name: string | Identifier, objectAssignmentInitializer?: Expression | undefined) => ShorthandPropertyAssignment;
8145    /** @deprecated Use `factory.updateShorthandPropertyAssignment` or the factory supplied by your transformation context instead. */
8146    const updateShorthandPropertyAssignment: (node: ShorthandPropertyAssignment, name: Identifier, objectAssignmentInitializer: Expression | undefined) => ShorthandPropertyAssignment;
8147    /** @deprecated Use `factory.createSpreadAssignment` or the factory supplied by your transformation context instead. */
8148    const createSpreadAssignment: (expression: Expression) => SpreadAssignment;
8149    /** @deprecated Use `factory.updateSpreadAssignment` or the factory supplied by your transformation context instead. */
8150    const updateSpreadAssignment: (node: SpreadAssignment, expression: Expression) => SpreadAssignment;
8151    /** @deprecated Use `factory.createEnumMember` or the factory supplied by your transformation context instead. */
8152    const createEnumMember: (name: string | PropertyName, initializer?: Expression | undefined) => EnumMember;
8153    /** @deprecated Use `factory.updateEnumMember` or the factory supplied by your transformation context instead. */
8154    const updateEnumMember: (node: EnumMember, name: PropertyName, initializer: Expression | undefined) => EnumMember;
8155    /** @deprecated Use `factory.updateSourceFile` or the factory supplied by your transformation context instead. */
8156    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;
8157    /** @deprecated Use `factory.createNotEmittedStatement` or the factory supplied by your transformation context instead. */
8158    const createNotEmittedStatement: (original: Node) => NotEmittedStatement;
8159    /** @deprecated Use `factory.createPartiallyEmittedExpression` or the factory supplied by your transformation context instead. */
8160    const createPartiallyEmittedExpression: (expression: Expression, original?: Node | undefined) => PartiallyEmittedExpression;
8161    /** @deprecated Use `factory.updatePartiallyEmittedExpression` or the factory supplied by your transformation context instead. */
8162    const updatePartiallyEmittedExpression: (node: PartiallyEmittedExpression, expression: Expression) => PartiallyEmittedExpression;
8163    /** @deprecated Use `factory.createCommaListExpression` or the factory supplied by your transformation context instead. */
8164    const createCommaList: (elements: readonly Expression[]) => CommaListExpression;
8165    /** @deprecated Use `factory.updateCommaListExpression` or the factory supplied by your transformation context instead. */
8166    const updateCommaList: (node: CommaListExpression, elements: readonly Expression[]) => CommaListExpression;
8167    /** @deprecated Use `factory.createBundle` or the factory supplied by your transformation context instead. */
8168    const createBundle: (sourceFiles: readonly SourceFile[], prepends?: readonly (UnparsedSource | InputFiles)[] | undefined) => Bundle;
8169    /** @deprecated Use `factory.updateBundle` or the factory supplied by your transformation context instead. */
8170    const updateBundle: (node: Bundle, sourceFiles: readonly SourceFile[], prepends?: readonly (UnparsedSource | InputFiles)[] | undefined) => Bundle;
8171    /** @deprecated Use `factory.createImmediatelyInvokedFunctionExpression` or the factory supplied by your transformation context instead. */
8172    const createImmediatelyInvokedFunctionExpression: {
8173        (statements: readonly Statement[]): CallExpression;
8174        (statements: readonly Statement[], param: ParameterDeclaration, paramValue: Expression): CallExpression;
8175    };
8176    /** @deprecated Use `factory.createImmediatelyInvokedArrowFunction` or the factory supplied by your transformation context instead. */
8177    const createImmediatelyInvokedArrowFunction: {
8178        (statements: readonly Statement[]): CallExpression;
8179        (statements: readonly Statement[], param: ParameterDeclaration, paramValue: Expression): CallExpression;
8180    };
8181    /** @deprecated Use `factory.createVoidZero` or the factory supplied by your transformation context instead. */
8182    const createVoidZero: () => VoidExpression;
8183    /** @deprecated Use `factory.createExportDefault` or the factory supplied by your transformation context instead. */
8184    const createExportDefault: (expression: Expression) => ExportAssignment;
8185    /** @deprecated Use `factory.createExternalModuleExport` or the factory supplied by your transformation context instead. */
8186    const createExternalModuleExport: (exportName: Identifier) => ExportDeclaration;
8187    /** @deprecated Use `factory.createNamespaceExport` or the factory supplied by your transformation context instead. */
8188    const createNamespaceExport: (name: Identifier) => NamespaceExport;
8189    /** @deprecated Use `factory.updateNamespaceExport` or the factory supplied by your transformation context instead. */
8190    const updateNamespaceExport: (node: NamespaceExport, name: Identifier) => NamespaceExport;
8191    /** @deprecated Use `factory.createToken` or the factory supplied by your transformation context instead. */
8192    const createToken: <TKind extends SyntaxKind>(kind: TKind) => Token<TKind>;
8193    /** @deprecated Use `factory.createIdentifier` or the factory supplied by your transformation context instead. */
8194    const createIdentifier: (text: string) => Identifier;
8195    /** @deprecated Use `factory.createTempVariable` or the factory supplied by your transformation context instead. */
8196    const createTempVariable: (recordTempVariable: ((node: Identifier) => void) | undefined) => Identifier;
8197    /** @deprecated Use `factory.getGeneratedNameForNode` or the factory supplied by your transformation context instead. */
8198    const getGeneratedNameForNode: (node: Node | undefined) => Identifier;
8199    /** @deprecated Use `factory.createUniqueName(text, GeneratedIdentifierFlags.Optimistic)` or the factory supplied by your transformation context instead. */
8200    const createOptimisticUniqueName: (text: string) => Identifier;
8201    /** @deprecated Use `factory.createUniqueName(text, GeneratedIdentifierFlags.Optimistic | GeneratedIdentifierFlags.FileLevel)` or the factory supplied by your transformation context instead. */
8202    const createFileLevelUniqueName: (text: string) => Identifier;
8203    /** @deprecated Use `factory.createIndexSignature` or the factory supplied by your transformation context instead. */
8204    const createIndexSignature: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode) => IndexSignatureDeclaration;
8205    /** @deprecated Use `factory.createTypePredicateNode` or the factory supplied by your transformation context instead. */
8206    const createTypePredicateNode: (parameterName: Identifier | ThisTypeNode | string, type: TypeNode) => TypePredicateNode;
8207    /** @deprecated Use `factory.updateTypePredicateNode` or the factory supplied by your transformation context instead. */
8208    const updateTypePredicateNode: (node: TypePredicateNode, parameterName: Identifier | ThisTypeNode, type: TypeNode) => TypePredicateNode;
8209    /** @deprecated Use `factory.createStringLiteral`, `factory.createStringLiteralFromNode`, `factory.createNumericLiteral`, `factory.createBigIntLiteral`, `factory.createTrue`, `factory.createFalse`, or the factory supplied by your transformation context instead. */
8210    const createLiteral: {
8211        (value: string | StringLiteral | NoSubstitutionTemplateLiteral | NumericLiteral | Identifier): StringLiteral;
8212        (value: number | PseudoBigInt): NumericLiteral;
8213        (value: boolean): BooleanLiteral;
8214        (value: string | number | PseudoBigInt | boolean): PrimaryExpression;
8215    };
8216    /** @deprecated Use `factory.createMethodSignature` or the factory supplied by your transformation context instead. */
8217    const createMethodSignature: (typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, name: string | PropertyName, questionToken: QuestionToken | undefined) => MethodSignature;
8218    /** @deprecated Use `factory.updateMethodSignature` or the factory supplied by your transformation context instead. */
8219    const updateMethodSignature: (node: MethodSignature, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined, name: PropertyName, questionToken: QuestionToken | undefined) => MethodSignature;
8220    /** @deprecated Use `factory.createTypeOperatorNode` or the factory supplied by your transformation context instead. */
8221    const createTypeOperatorNode: {
8222        (type: TypeNode): TypeOperatorNode;
8223        (operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword, type: TypeNode): TypeOperatorNode;
8224    };
8225    /** @deprecated Use `factory.createTaggedTemplate` or the factory supplied by your transformation context instead. */
8226    const createTaggedTemplate: {
8227        (tag: Expression, template: TemplateLiteral): TaggedTemplateExpression;
8228        (tag: Expression, typeArguments: readonly TypeNode[] | undefined, template: TemplateLiteral): TaggedTemplateExpression;
8229    };
8230    /** @deprecated Use `factory.updateTaggedTemplate` or the factory supplied by your transformation context instead. */
8231    const updateTaggedTemplate: {
8232        (node: TaggedTemplateExpression, tag: Expression, template: TemplateLiteral): TaggedTemplateExpression;
8233        (node: TaggedTemplateExpression, tag: Expression, typeArguments: readonly TypeNode[] | undefined, template: TemplateLiteral): TaggedTemplateExpression;
8234    };
8235    /** @deprecated Use `factory.updateBinary` or the factory supplied by your transformation context instead. */
8236    const updateBinary: (node: BinaryExpression, left: Expression, right: Expression, operator?: BinaryOperator | BinaryOperatorToken) => BinaryExpression;
8237    /** @deprecated Use `factory.createConditional` or the factory supplied by your transformation context instead. */
8238    const createConditional: {
8239        (condition: Expression, whenTrue: Expression, whenFalse: Expression): ConditionalExpression;
8240        (condition: Expression, questionToken: QuestionToken, whenTrue: Expression, colonToken: ColonToken, whenFalse: Expression): ConditionalExpression;
8241    };
8242    /** @deprecated Use `factory.createYield` or the factory supplied by your transformation context instead. */
8243    const createYield: {
8244        (expression?: Expression | undefined): YieldExpression;
8245        (asteriskToken: AsteriskToken | undefined, expression: Expression): YieldExpression;
8246    };
8247    /** @deprecated Use `factory.createClassExpression` or the factory supplied by your transformation context instead. */
8248    const createClassExpression: (modifiers: readonly Modifier[] | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]) => ClassExpression;
8249    /** @deprecated Use `factory.updateClassExpression` or the factory supplied by your transformation context instead. */
8250    const updateClassExpression: (node: ClassExpression, modifiers: readonly Modifier[] | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]) => ClassExpression;
8251    /** @deprecated Use `factory.createPropertySignature` or the factory supplied by your transformation context instead. */
8252    const createPropertySignature: (modifiers: readonly Modifier[] | undefined, name: PropertyName | string, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer?: Expression | undefined) => PropertySignature;
8253    /** @deprecated Use `factory.updatePropertySignature` or the factory supplied by your transformation context instead. */
8254    const updatePropertySignature: (node: PropertySignature, modifiers: readonly Modifier[] | undefined, name: PropertyName, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined) => PropertySignature;
8255    /** @deprecated Use `factory.createExpressionWithTypeArguments` or the factory supplied by your transformation context instead. */
8256    const createExpressionWithTypeArguments: (typeArguments: readonly TypeNode[] | undefined, expression: Expression) => ExpressionWithTypeArguments;
8257    /** @deprecated Use `factory.updateExpressionWithTypeArguments` or the factory supplied by your transformation context instead. */
8258    const updateExpressionWithTypeArguments: (node: ExpressionWithTypeArguments, typeArguments: readonly TypeNode[] | undefined, expression: Expression) => ExpressionWithTypeArguments;
8259    /** @deprecated Use `factory.createArrowFunction` or the factory supplied by your transformation context instead. */
8260    const createArrowFunction: {
8261        (modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, equalsGreaterThanToken: EqualsGreaterThanToken | undefined, body: ConciseBody): ArrowFunction;
8262        (modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: ConciseBody): ArrowFunction;
8263    };
8264    /** @deprecated Use `factory.updateArrowFunction` or the factory supplied by your transformation context instead. */
8265    const updateArrowFunction: {
8266        (node: ArrowFunction, modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, equalsGreaterThanToken: EqualsGreaterThanToken, body: ConciseBody): ArrowFunction;
8267        (node: ArrowFunction, modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: ConciseBody): ArrowFunction;
8268    };
8269    /** @deprecated Use `factory.createVariableDeclaration` or the factory supplied by your transformation context instead. */
8270    const createVariableDeclaration: {
8271        (name: string | BindingName, type?: TypeNode | undefined, initializer?: Expression | undefined): VariableDeclaration;
8272        (name: string | BindingName, exclamationToken: ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): VariableDeclaration;
8273    };
8274    /** @deprecated Use `factory.updateVariableDeclaration` or the factory supplied by your transformation context instead. */
8275    const updateVariableDeclaration: {
8276        (node: VariableDeclaration, name: BindingName, type: TypeNode | undefined, initializer: Expression | undefined): VariableDeclaration;
8277        (node: VariableDeclaration, name: BindingName, exclamationToken: ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): VariableDeclaration;
8278    };
8279    /** @deprecated Use `factory.createImportClause` or the factory supplied by your transformation context instead. */
8280    const createImportClause: (name: Identifier | undefined, namedBindings: NamedImportBindings | undefined, isTypeOnly?: any) => ImportClause;
8281    /** @deprecated Use `factory.updateImportClause` or the factory supplied by your transformation context instead. */
8282    const updateImportClause: (node: ImportClause, name: Identifier | undefined, namedBindings: NamedImportBindings | undefined, isTypeOnly: boolean) => ImportClause;
8283    /** @deprecated Use `factory.createExportDeclaration` or the factory supplied by your transformation context instead. */
8284    const createExportDeclaration: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, exportClause: NamedExportBindings | undefined, moduleSpecifier?: Expression | undefined, isTypeOnly?: any) => ExportDeclaration;
8285    /** @deprecated Use `factory.updateExportDeclaration` or the factory supplied by your transformation context instead. */
8286    const updateExportDeclaration: (node: ExportDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, exportClause: NamedExportBindings | undefined, moduleSpecifier: Expression | undefined, isTypeOnly: boolean) => ExportDeclaration;
8287    /** @deprecated Use `factory.createJSDocParameterTag` or the factory supplied by your transformation context instead. */
8288    const createJSDocParamTag: (name: EntityName, isBracketed: boolean, typeExpression?: JSDocTypeExpression | undefined, comment?: string | undefined) => JSDocParameterTag;
8289    /** @deprecated Use `factory.createComma` or the factory supplied by your transformation context instead. */
8290    const createComma: (left: Expression, right: Expression) => Expression;
8291    /** @deprecated Use `factory.createLessThan` or the factory supplied by your transformation context instead. */
8292    const createLessThan: (left: Expression, right: Expression) => Expression;
8293    /** @deprecated Use `factory.createAssignment` or the factory supplied by your transformation context instead. */
8294    const createAssignment: (left: Expression, right: Expression) => BinaryExpression;
8295    /** @deprecated Use `factory.createStrictEquality` or the factory supplied by your transformation context instead. */
8296    const createStrictEquality: (left: Expression, right: Expression) => BinaryExpression;
8297    /** @deprecated Use `factory.createStrictInequality` or the factory supplied by your transformation context instead. */
8298    const createStrictInequality: (left: Expression, right: Expression) => BinaryExpression;
8299    /** @deprecated Use `factory.createAdd` or the factory supplied by your transformation context instead. */
8300    const createAdd: (left: Expression, right: Expression) => BinaryExpression;
8301    /** @deprecated Use `factory.createSubtract` or the factory supplied by your transformation context instead. */
8302    const createSubtract: (left: Expression, right: Expression) => BinaryExpression;
8303    /** @deprecated Use `factory.createLogicalAnd` or the factory supplied by your transformation context instead. */
8304    const createLogicalAnd: (left: Expression, right: Expression) => BinaryExpression;
8305    /** @deprecated Use `factory.createLogicalOr` or the factory supplied by your transformation context instead. */
8306    const createLogicalOr: (left: Expression, right: Expression) => BinaryExpression;
8307    /** @deprecated Use `factory.createPostfixIncrement` or the factory supplied by your transformation context instead. */
8308    const createPostfixIncrement: (operand: Expression) => PostfixUnaryExpression;
8309    /** @deprecated Use `factory.createLogicalNot` or the factory supplied by your transformation context instead. */
8310    const createLogicalNot: (operand: Expression) => PrefixUnaryExpression;
8311    /** @deprecated Use an appropriate `factory` method instead. */
8312    const createNode: (kind: SyntaxKind, pos?: any, end?: any) => Node;
8313    /**
8314     * Creates a shallow, memberwise clone of a node ~for mutation~ with its `pos`, `end`, and `parent` set.
8315     *
8316     * NOTE: It is unsafe to change any properties of a `Node` that relate to its AST children, as those changes won't be
8317     * captured with respect to transformations.
8318     *
8319     * @deprecated Use an appropriate `factory.update...` method instead, use `setCommentRange` or `setSourceMapRange`, and avoid setting `parent`.
8320     */
8321    const getMutableClone: <T extends Node>(node: T) => T;
8322}
8323declare namespace ts {
8324    /** @deprecated Use `isTypeAssertionExpression` instead. */
8325    const isTypeAssertion: (node: Node) => node is TypeAssertion;
8326}
8327declare namespace ts {
8328    /**
8329     * @deprecated Use `ts.ReadonlyESMap<K, V>` instead.
8330     */
8331    interface ReadonlyMap<T> extends ReadonlyESMap<string, T> {
8332    }
8333    /**
8334     * @deprecated Use `ts.ESMap<K, V>` instead.
8335     */
8336    interface Map<T> extends ESMap<string, T> {
8337    }
8338}
8339declare namespace ts {
8340    /**
8341     * @deprecated Use `isMemberName` instead.
8342     */
8343    const isIdentifierOrPrivateIdentifier: (node: Node) => node is MemberName;
8344}
8345declare namespace ts {
8346    interface NodeFactory {
8347        /** @deprecated Use the overload that accepts 'modifiers' */
8348        createConstructorTypeNode(typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): ConstructorTypeNode;
8349        /** @deprecated Use the overload that accepts 'modifiers' */
8350        updateConstructorTypeNode(node: ConstructorTypeNode, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode): ConstructorTypeNode;
8351    }
8352}
8353declare namespace ts {
8354    interface NodeFactory {
8355        createImportTypeNode(argument: TypeNode, assertions?: ImportTypeAssertionContainer, qualifier?: EntityName, typeArguments?: readonly TypeNode[], isTypeOf?: boolean): ImportTypeNode;
8356        /** @deprecated Use the overload that accepts 'assertions' */
8357        createImportTypeNode(argument: TypeNode, qualifier?: EntityName, typeArguments?: readonly TypeNode[], isTypeOf?: boolean): ImportTypeNode;
8358        /** @deprecated Use the overload that accepts 'assertions' */
8359        updateImportTypeNode(node: ImportTypeNode, argument: TypeNode, qualifier: EntityName | undefined, typeArguments: readonly TypeNode[] | undefined, isTypeOf?: boolean): ImportTypeNode;
8360    }
8361}
8362declare namespace ts {
8363    interface NodeFactory {
8364        /** @deprecated Use the overload that accepts 'modifiers' */
8365        createTypeParameterDeclaration(name: string | Identifier, constraint?: TypeNode, defaultType?: TypeNode): TypeParameterDeclaration;
8366        /** @deprecated Use the overload that accepts 'modifiers' */
8367        updateTypeParameterDeclaration(node: TypeParameterDeclaration, name: Identifier, constraint: TypeNode | undefined, defaultType: TypeNode | undefined): TypeParameterDeclaration;
8368    }
8369}
8370declare namespace ts {
8371    interface Node {
8372        /**
8373         * @deprecated `decorators` has been removed from `Node` and merged with `modifiers` on the `Node` subtypes that support them.
8374         * Use `ts.canHaveDecorators()` to test whether a `Node` can have decorators.
8375         * Use `ts.getDecorators()` to get the decorators of a `Node`.
8376         *
8377         * For example:
8378         * ```ts
8379         * const decorators = ts.canHaveDecorators(node) ? ts.getDecorators(node) : undefined;
8380         * ```
8381         */
8382        readonly decorators?: undefined;
8383        /**
8384         * @deprecated `modifiers` has been removed from `Node` and moved to the `Node` subtypes that support them.
8385         * Use `ts.canHaveModifiers()` to test whether a `Node` can have modifiers.
8386         * Use `ts.getModifiers()` to get the modifiers of a `Node`.
8387         *
8388         * For example:
8389         * ```ts
8390         * const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
8391         * ```
8392         */
8393        readonly modifiers?: NodeArray<ModifierLike> | undefined;
8394    }
8395    interface PropertySignature {
8396        /** @deprecated A property signature cannot have an initializer */
8397        readonly initializer?: Expression | undefined;
8398    }
8399    interface PropertyAssignment {
8400        /** @deprecated A property assignment cannot have a question token */
8401        readonly questionToken?: QuestionToken | undefined;
8402        /** @deprecated A property assignment cannot have an exclamation token */
8403        readonly exclamationToken?: ExclamationToken | undefined;
8404    }
8405    interface ShorthandPropertyAssignment {
8406        /** @deprecated A shorthand property assignment cannot have modifiers */
8407        readonly modifiers?: NodeArray<Modifier> | undefined;
8408        /** @deprecated A shorthand property assignment cannot have a question token */
8409        readonly questionToken?: QuestionToken | undefined;
8410        /** @deprecated A shorthand property assignment cannot have an exclamation token */
8411        readonly exclamationToken?: ExclamationToken | undefined;
8412    }
8413    interface FunctionTypeNode {
8414        /** @deprecated A function type cannot have modifiers */
8415        readonly modifiers?: NodeArray<Modifier> | undefined;
8416    }
8417    interface NodeFactory {
8418        /**
8419         * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
8420         */
8421        createParameterDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken?: QuestionToken, type?: TypeNode, initializer?: Expression): ParameterDeclaration;
8422        /**
8423         * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
8424         */
8425        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;
8426        /**
8427         * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
8428         */
8429        createPropertyDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertyDeclaration;
8430        /**
8431         * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
8432         */
8433        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;
8434        /**
8435         * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
8436         */
8437        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;
8438        /**
8439         * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
8440         */
8441        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;
8442        /**
8443         * @deprecated This node does not support Decorators. Callers should use an overload that does not accept a `decorators` parameter.
8444         */
8445        createConstructorDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], body: Block | undefined): ConstructorDeclaration;
8446        /**
8447         * @deprecated This node does not support Decorators. Callers should use an overload that does not accept a `decorators` parameter.
8448         */
8449        updateConstructorDeclaration(node: ConstructorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], body: Block | undefined): ConstructorDeclaration;
8450        /**
8451         * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
8452         */
8453        createGetAccessorDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): GetAccessorDeclaration;
8454        /**
8455         * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
8456         */
8457        updateGetAccessorDeclaration(node: GetAccessorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: PropertyName, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): GetAccessorDeclaration;
8458        /**
8459         * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
8460         */
8461        createSetAccessorDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, parameters: readonly ParameterDeclaration[], body: Block | undefined): SetAccessorDeclaration;
8462        /**
8463         * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
8464         */
8465        updateSetAccessorDeclaration(node: SetAccessorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: PropertyName, parameters: readonly ParameterDeclaration[], body: Block | undefined): SetAccessorDeclaration;
8466        /**
8467         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8468         */
8469        createIndexSignature(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration;
8470        /**
8471         * @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.
8472         */
8473        updateIndexSignature(node: IndexSignatureDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration;
8474        /**
8475         * @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.
8476         */
8477        createClassStaticBlockDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, body: Block): ClassStaticBlockDeclaration;
8478        /**
8479         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8480         */
8481        updateClassStaticBlockDeclaration(node: ClassStaticBlockDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, body: Block): ClassStaticBlockDeclaration;
8482        /**
8483         * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
8484         */
8485        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;
8486        /**
8487         * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
8488         */
8489        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;
8490        /**
8491         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8492         */
8493        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;
8494        /**
8495         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8496         */
8497        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;
8498        /**
8499         * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
8500         */
8501        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;
8502        /**
8503         * @deprecated Decorators have been combined with modifiers. Callers should use an overload that does not accept a `decorators` parameter.
8504         */
8505        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;
8506        /**
8507         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8508         */
8509        createInterfaceDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly TypeElement[]): InterfaceDeclaration;
8510        /**
8511         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8512         */
8513        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;
8514        /**
8515         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8516         */
8517        createTypeAliasDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration;
8518        /**
8519         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8520         */
8521        updateTypeAliasDeclaration(node: TypeAliasDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, typeParameters: readonly TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration;
8522        /**
8523         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8524         */
8525        createEnumDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, members: readonly EnumMember[]): EnumDeclaration;
8526        /**
8527         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8528         */
8529        updateEnumDeclaration(node: EnumDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, members: readonly EnumMember[]): EnumDeclaration;
8530        /**
8531         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8532         */
8533        createModuleDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined, flags?: NodeFlags): ModuleDeclaration;
8534        /**
8535         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8536         */
8537        updateModuleDeclaration(node: ModuleDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined): ModuleDeclaration;
8538        /**
8539         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8540         */
8541        createImportEqualsDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: string | Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration;
8542        /**
8543         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8544         */
8545        updateImportEqualsDeclaration(node: ImportEqualsDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration;
8546        /**
8547         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8548         */
8549        createImportDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause?: AssertClause): ImportDeclaration;
8550        /**
8551         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8552         */
8553        updateImportDeclaration(node: ImportDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, assertClause: AssertClause | undefined): ImportDeclaration;
8554        /**
8555         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8556         */
8557        createExportAssignment(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isExportEquals: boolean | undefined, expression: Expression): ExportAssignment;
8558        /**
8559         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8560         */
8561        updateExportAssignment(node: ExportAssignment, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, expression: Expression): ExportAssignment;
8562        /**
8563         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8564         */
8565        createExportDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, exportClause: NamedExportBindings | undefined, moduleSpecifier?: Expression, assertClause?: AssertClause): ExportDeclaration;
8566        /**
8567         * @deprecated Decorators are no longer supported for this function. Callers should use an overload that does not accept a `decorators` parameter.
8568         */
8569        updateExportDeclaration(node: ExportDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, exportClause: NamedExportBindings | undefined, moduleSpecifier: Expression | undefined, assertClause: AssertClause | undefined): ExportDeclaration;
8570    }
8571}
8572declare namespace ts {
8573    namespace ArkTSLinter_1_0 {
8574        namespace Common {
8575            interface AutofixInfo {
8576                problemID: string;
8577                start: number;
8578                end: number;
8579            }
8580            interface CommandLineOptions {
8581                strictMode?: boolean;
8582                ideMode?: boolean;
8583                logTscErrors?: boolean;
8584                warningsAsErrors: boolean;
8585                parsedConfigFile?: ParsedCommandLine;
8586                inputFiles: string[];
8587                autofixInfo?: AutofixInfo[];
8588            }
8589            interface LintOptions {
8590                cmdOptions: CommandLineOptions;
8591                tsProgram?: Program;
8592                [key: string]: any;
8593            }
8594        }
8595    }
8596}
8597declare namespace ts {
8598    namespace ArkTSLinter_1_0 {
8599        const cookBookMsg: string[];
8600        const cookBookTag: string[];
8601    }
8602}
8603declare namespace ts {
8604    namespace ArkTSLinter_1_0 {
8605        namespace DiagnosticCheckerNamespace {
8606            interface DiagnosticChecker {
8607                checkDiagnosticMessage(msgText: string | ts.DiagnosticMessageChain): boolean;
8608            }
8609        }
8610    }
8611}
8612declare namespace ts {
8613    namespace ArkTSLinter_1_0 {
8614        import DiagnosticChecker = DiagnosticCheckerNamespace.DiagnosticChecker;
8615        namespace LibraryTypeCallDiagnosticCheckerNamespace {
8616            const TYPE_0_IS_NOT_ASSIGNABLE_TO_TYPE_1_ERROR_CODE = 2322;
8617            const TYPE_UNKNOWN_IS_NOT_ASSIGNABLE_TO_TYPE_1_RE: RegExp;
8618            const TYPE_NULL_IS_NOT_ASSIGNABLE_TO_TYPE_1_RE: RegExp;
8619            const TYPE_UNDEFINED_IS_NOT_ASSIGNABLE_TO_TYPE_1_RE: RegExp;
8620            const ARGUMENT_OF_TYPE_0_IS_NOT_ASSIGNABLE_TO_PARAMETER_OF_TYPE_1_ERROR_CODE = 2345;
8621            const ARGUMENT_OF_TYPE_NULL_IS_NOT_ASSIGNABLE_TO_PARAMETER_OF_TYPE_1_RE: RegExp;
8622            const ARGUMENT_OF_TYPE_UNDEFINED_IS_NOT_ASSIGNABLE_TO_PARAMETER_OF_TYPE_1_RE: RegExp;
8623            const NO_OVERLOAD_MATCHES_THIS_CALL_ERROR_CODE = 2769;
8624            class LibraryTypeCallDiagnosticChecker implements DiagnosticChecker {
8625                inLibCall: boolean;
8626                diagnosticMessages: Array<ts.DiagnosticMessageChain> | undefined;
8627                filteredDiagnosticMessages: DiagnosticMessageChain[];
8628                constructor(filteredDiagnosticMessages: DiagnosticMessageChain[]);
8629                configure(inLibCall: boolean, diagnosticMessages: Array<ts.DiagnosticMessageChain>): void;
8630                checkMessageText(msg: string): boolean;
8631                checkMessageChain(chain: ts.DiagnosticMessageChain): boolean;
8632                checkFilteredDiagnosticMessages(msgText: ts.DiagnosticMessageChain | string): boolean;
8633                checkDiagnosticMessage(msgText: string | ts.DiagnosticMessageChain): boolean;
8634            }
8635        }
8636    }
8637}
8638declare namespace ts {
8639    namespace ArkTSLinter_1_0 {
8640        namespace Utils {
8641            import AutofixInfo = Common.AutofixInfo;
8642            const PROPERTY_HAS_NO_INITIALIZER_ERROR_CODE = 2564;
8643            const NON_INITIALIZABLE_PROPERTY_DECORATORS: string[];
8644            const NON_INITIALIZABLE_PROPERTY_ClASS_DECORATORS: string[];
8645            const LIMITED_STANDARD_UTILITY_TYPES: string[];
8646            const ALLOWED_STD_SYMBOL_API: string[];
8647            enum ProblemSeverity {
8648                WARNING = 1,
8649                ERROR = 2
8650            }
8651            const ARKTS_IGNORE_DIRS: string[];
8652            const ARKTS_IGNORE_FILES: string[];
8653            function setTypeChecker(tsTypeChecker: TypeChecker): void;
8654            function clearTypeChecker(): void;
8655            function setTestMode(tsTestMode: boolean): void;
8656            function getStartPos(nodeOrComment: Node | CommentRange): number;
8657            function getEndPos(nodeOrComment: Node | CommentRange): number;
8658            function isAssignmentOperator(tsBinOp: BinaryOperatorToken): boolean;
8659            function isTypedArray(tsType: TypeNode | undefined): boolean;
8660            function isType(tsType: TypeNode | undefined, checkType: string): boolean;
8661            function entityNameToString(name: EntityName): string;
8662            function isNumberType(tsType: Type): boolean;
8663            function isBooleanType(tsType: Type): boolean;
8664            function isStringLikeType(tsType: Type): boolean;
8665            function isStringType(type: Type): boolean;
8666            function isPrimitiveEnumType(type: Type, primitiveType: TypeFlags): boolean;
8667            function isPrimitiveEnumMemberType(type: Type, primitiveType: TypeFlags): boolean;
8668            function unwrapParenthesizedType(tsType: TypeNode): TypeNode;
8669            function findParentIf(asExpr: AsExpression): IfStatement | null;
8670            function isDestructuringAssignmentLHS(tsExpr: ArrayLiteralExpression | ObjectLiteralExpression): boolean;
8671            function isEnumType(tsType: Type): boolean;
8672            function isEnumMemberType(tsType: Type): boolean;
8673            function isObjectLiteralType(tsType: Type): boolean;
8674            function isNumberLikeType(tsType: Type): boolean;
8675            function hasModifier(tsModifiers: readonly Modifier[] | undefined, tsModifierKind: number): boolean;
8676            function unwrapParenthesized(tsExpr: Expression): Expression;
8677            function followIfAliased(sym: Symbol): Symbol;
8678            function trueSymbolAtLocation(node: Node): Symbol | undefined;
8679            function clearTrueSymbolAtLocationCache(): void;
8680            function isTypeDeclSyntaxKind(kind: SyntaxKind): boolean;
8681            function symbolHasDuplicateName(symbol: Symbol, tsDeclKind: SyntaxKind): boolean;
8682            function isReferenceType(tsType: Type): boolean;
8683            function isPrimitiveType(type: Type): boolean;
8684            function isTypeSymbol(symbol: Symbol | undefined): boolean;
8685            function isGenericArrayType(tsType: Type): tsType is TypeReference;
8686            function isDerivedFrom(tsType: Type, checkType: CheckType): tsType is TypeReference;
8687            function isTypeReference(tsType: Type): tsType is TypeReference;
8688            function isNullType(tsTypeNode: TypeNode): boolean;
8689            function isThisOrSuperExpr(tsExpr: Expression): boolean;
8690            function isPrototypeSymbol(symbol: Symbol | undefined): boolean;
8691            function isFunctionSymbol(symbol: Symbol | undefined): boolean;
8692            function isInterfaceType(tsType: Type | undefined): boolean;
8693            function isAnyType(tsType: Type): tsType is TypeReference;
8694            function isUnknownType(tsType: Type): boolean;
8695            function isUnsupportedType(tsType: Type): boolean;
8696            function isUnsupportedUnionType(tsType: Type): boolean;
8697            function isFunctionOrMethod(tsSymbol: Symbol | undefined): boolean;
8698            function isMethodAssignment(tsSymbol: Symbol | undefined): boolean;
8699            function getDeclaration(tsSymbol: ts.Symbol | undefined): ts.Declaration | undefined;
8700            function isValidEnumMemberInit(tsExpr: Expression): boolean;
8701            function isCompileTimeExpression(tsExpr: Expression): boolean;
8702            function isConst(tsNode: Node): boolean;
8703            function isNumberConstantValue(tsExpr: EnumMember | PropertyAccessExpression | ElementAccessExpression | NumericLiteral): boolean;
8704            function isIntegerConstantValue(tsExpr: EnumMember | PropertyAccessExpression | ElementAccessExpression | NumericLiteral): boolean;
8705            function isStringConstantValue(tsExpr: EnumMember | PropertyAccessExpression | ElementAccessExpression): boolean;
8706            function relatedByInheritanceOrIdentical(typeA: Type, typeB: Type): boolean;
8707            function needToDeduceStructuralIdentity(typeFrom: Type, typeTo: Type, allowPromotion?: boolean): boolean;
8708            function hasPredecessor(node: Node, predicate: (node: Node) => boolean): boolean;
8709            function processParentTypes(parentTypes: NodeArray<ExpressionWithTypeArguments>, typeB: Type, processInterfaces: boolean): boolean;
8710            function processParentTypesCheck(parentTypes: NodeArray<ExpressionWithTypeArguments>, checkType: CheckType): boolean;
8711            function isObjectType(tsType: Type): boolean;
8712            function logTscDiagnostic(diagnostics: readonly Diagnostic[], log: (message: any, ...args: any[]) => void): void;
8713            function encodeProblemInfo(problem: ProblemInfo): string;
8714            function decodeAutofixInfo(info: string): AutofixInfo;
8715            function isCallToFunctionWithOmittedReturnType(tsExpr: Expression): boolean;
8716            function validateObjectLiteralType(type: Type | undefined): boolean;
8717            function isStructDeclarationKind(kind: SyntaxKind): boolean;
8718            function isStructDeclaration(node: Node): boolean;
8719            function isStructObjectInitializer(objectLiteral: ObjectLiteralExpression): boolean;
8720            function hasMethods(type: Type): boolean;
8721            function isExpressionAssignableToType(lhsType: ts.Type | undefined, rhsExpr: ts.Expression): boolean;
8722            function isLiteralType(type: Type): boolean;
8723            function validateFields(type: Type, objectLiteral: ObjectLiteralExpression): boolean;
8724            function isSupportedType(typeNode: TypeNode): boolean;
8725            function isStruct(symbol: Symbol): boolean;
8726            enum CheckType {
8727                Array = 0,
8728                String = "String",
8729                Set = "Set",
8730                Map = "Map",
8731                Error = "Error"
8732            }
8733            const ES_OBJECT = "ESObject";
8734            const LIMITED_STD_GLOBAL_FUNC: string[];
8735            const LIMITED_STD_OBJECT_API: string[];
8736            const LIMITED_STD_REFLECT_API: string[];
8737            const LIMITED_STD_PROXYHANDLER_API: string[];
8738            const ARKUI_DECORATORS: string[];
8739            const FUNCTION_HAS_NO_RETURN_ERROR_CODE = 2366;
8740            const NON_RETURN_FUNCTION_DECORATORS: string[];
8741            const STANDARD_LIBRARIES: string[];
8742            const TYPED_ARRAYS: string[];
8743            function getParentSymbolName(symbol: Symbol): string | undefined;
8744            function isGlobalSymbol(symbol: Symbol): boolean;
8745            function isSymbolAPI(symbol: Symbol): boolean;
8746            function isStdSymbol(symbol: ts.Symbol): boolean;
8747            function isSymbolIterator(symbol: ts.Symbol): boolean;
8748            function isDefaultImport(importSpec: ImportSpecifier): boolean;
8749            function hasAccessModifier(decl: Declaration): boolean;
8750            function getModifier(modifiers: readonly Modifier[] | undefined, modifierKind: SyntaxKind): Modifier | undefined;
8751            function getAccessModifier(modifiers: readonly Modifier[] | undefined): Modifier | undefined;
8752            function isStdRecordType(type: Type): boolean;
8753            function isStdPartialType(type: Type): boolean;
8754            function isStdRequiredType(type: Type): boolean;
8755            function isStdReadonlyType(type: Type): boolean;
8756            function isLibraryType(type: Type): boolean;
8757            function hasLibraryType(node: Node): boolean;
8758            function isLibrarySymbol(sym: Symbol | undefined): boolean;
8759            function pathContainsDirectory(targetPath: string, dir: string): boolean;
8760            function getScriptKind(srcFile: SourceFile): ScriptKind;
8761            function isStdLibraryType(type: Type): boolean;
8762            function isStdLibrarySymbol(sym: Symbol | undefined): boolean;
8763            function isIntrinsicObjectType(type: Type): boolean;
8764            function isDynamicType(type: Type | undefined): boolean | undefined;
8765            function isDynamicLiteralInitializer(expr: Expression): boolean;
8766            function isEsObjectType(typeNode: TypeNode): boolean;
8767            function isInsideBlock(node: ts.Node): boolean;
8768            function isEsObjectPossiblyAllowed(typeRef: ts.TypeReferenceNode): boolean;
8769            function isValueAssignableToESObject(node: ts.Node): boolean;
8770            function getVariableDeclarationTypeNode(node: Node): TypeNode | undefined;
8771            function getSymbolDeclarationTypeNode(sym: ts.Symbol): ts.TypeNode | undefined;
8772            function hasEsObjectType(node: Node): boolean;
8773            function symbolHasEsObjectType(sym: ts.Symbol): boolean;
8774            function isEsObjectSymbol(sym: Symbol): boolean;
8775            function isAnonymousType(type: Type): boolean;
8776            function getSymbolOfCallExpression(callExpr: CallExpression): Symbol | undefined;
8777            function typeIsRecursive(topType: Type, type?: Type | undefined): boolean;
8778        }
8779    }
8780}
8781declare namespace ts {
8782    namespace ArkTSLinter_1_0 {
8783        namespace Problems {
8784            enum FaultID {
8785                AnyType = 0,
8786                SymbolType = 1,
8787                ObjectLiteralNoContextType = 2,
8788                ArrayLiteralNoContextType = 3,
8789                ComputedPropertyName = 4,
8790                LiteralAsPropertyName = 5,
8791                TypeQuery = 6,
8792                RegexLiteral = 7,
8793                IsOperator = 8,
8794                DestructuringParameter = 9,
8795                YieldExpression = 10,
8796                InterfaceMerging = 11,
8797                EnumMerging = 12,
8798                InterfaceExtendsClass = 13,
8799                IndexMember = 14,
8800                WithStatement = 15,
8801                ThrowStatement = 16,
8802                IndexedAccessType = 17,
8803                UnknownType = 18,
8804                ForInStatement = 19,
8805                InOperator = 20,
8806                ImportFromPath = 21,
8807                FunctionExpression = 22,
8808                IntersectionType = 23,
8809                ObjectTypeLiteral = 24,
8810                CommaOperator = 25,
8811                LimitedReturnTypeInference = 26,
8812                LambdaWithTypeParameters = 27,
8813                ClassExpression = 28,
8814                DestructuringAssignment = 29,
8815                DestructuringDeclaration = 30,
8816                VarDeclaration = 31,
8817                CatchWithUnsupportedType = 32,
8818                DeleteOperator = 33,
8819                DeclWithDuplicateName = 34,
8820                UnaryArithmNotNumber = 35,
8821                ConstructorType = 36,
8822                ConstructorIface = 37,
8823                ConstructorFuncs = 38,
8824                CallSignature = 39,
8825                TypeAssertion = 40,
8826                PrivateIdentifier = 41,
8827                LocalFunction = 42,
8828                ConditionalType = 43,
8829                MappedType = 44,
8830                NamespaceAsObject = 45,
8831                ClassAsObject = 46,
8832                NonDeclarationInNamespace = 47,
8833                GeneratorFunction = 48,
8834                FunctionContainsThis = 49,
8835                PropertyAccessByIndex = 50,
8836                JsxElement = 51,
8837                EnumMemberNonConstInit = 52,
8838                ImplementsClass = 53,
8839                NoUndefinedPropAccess = 54,
8840                MultipleStaticBlocks = 55,
8841                ThisType = 56,
8842                IntefaceExtendDifProps = 57,
8843                StructuralIdentity = 58,
8844                DefaultImport = 59,
8845                ExportAssignment = 60,
8846                ImportAssignment = 61,
8847                GenericCallNoTypeArgs = 62,
8848                ParameterProperties = 63,
8849                InstanceofUnsupported = 64,
8850                ShorthandAmbientModuleDecl = 65,
8851                WildcardsInModuleName = 66,
8852                UMDModuleDefinition = 67,
8853                NewTarget = 68,
8854                DefiniteAssignment = 69,
8855                Prototype = 70,
8856                GlobalThis = 71,
8857                UtilityType = 72,
8858                PropertyDeclOnFunction = 73,
8859                FunctionApplyBindCall = 74,
8860                ConstAssertion = 75,
8861                ImportAssertion = 76,
8862                SpreadOperator = 77,
8863                LimitedStdLibApi = 78,
8864                ErrorSuppression = 79,
8865                StrictDiagnostic = 80,
8866                UnsupportedDecorators = 81,
8867                ImportAfterStatement = 82,
8868                EsObjectType = 83,
8869                LAST_ID = 84
8870            }
8871            class FaultAttributs {
8872                migratable?: boolean;
8873                warning?: boolean;
8874                cookBookRef: string;
8875            }
8876            const faultsAttrs: FaultAttributs[];
8877        }
8878    }
8879}
8880declare namespace ts {
8881    namespace ArkTSLinter_1_0 {
8882        namespace Autofixer {
8883            import AutofixInfo = Common.AutofixInfo;
8884            import FaultID = Problems.FaultID;
8885            const AUTOFIX_ALL: AutofixInfo;
8886            const autofixInfo: AutofixInfo[];
8887            function shouldAutofix(node: Node, faultID: FaultID): boolean;
8888            interface Autofix {
8889                replacementText: string;
8890                start: number;
8891                end: number;
8892            }
8893            function fixLiteralAsPropertyName(node: Node): Autofix[] | undefined;
8894            function fixPropertyAccessByIndex(node: Node): Autofix[] | undefined;
8895            function fixFunctionExpression(funcExpr: FunctionExpression, params?: NodeArray<ParameterDeclaration>, retType?: TypeNode | undefined): Autofix;
8896            function fixReturnType(funcLikeDecl: FunctionLikeDeclaration, typeNode: TypeNode): Autofix;
8897            function fixCtorParameterProperties(ctorDecl: ConstructorDeclaration, paramTypes: TypeNode[]): Autofix[] | undefined;
8898        }
8899    }
8900}
8901declare namespace ts {
8902    namespace ArkTSLinter_1_0 {
8903        import FaultID = Problems.FaultID;
8904        class LinterConfig {
8905            static nodeDesc: string[];
8906            static tsSyntaxKindNames: string[];
8907            static initStatic(): void;
8908            static terminalTokens: Set<SyntaxKind>;
8909            static incrementOnlyTokens: ESMap<SyntaxKind, FaultID>;
8910        }
8911    }
8912}
8913declare namespace ts {
8914    namespace ArkTSLinter_1_0 {
8915        import Autofix = Autofixer.Autofix;
8916        import LibraryTypeCallDiagnosticChecker = LibraryTypeCallDiagnosticCheckerNamespace.LibraryTypeCallDiagnosticChecker;
8917        interface ProblemInfo {
8918            line: number;
8919            column: number;
8920            start: number;
8921            end: number;
8922            type: string;
8923            severity: number;
8924            problem: string;
8925            suggest: string;
8926            rule: string;
8927            ruleTag: number;
8928            autofixable: boolean;
8929            autofix?: Autofix[];
8930        }
8931        class TypeScriptLinter {
8932            private sourceFile;
8933            private tscStrictDiagnostics?;
8934            static ideMode: boolean;
8935            static strictMode: boolean;
8936            static logTscErrors: boolean;
8937            static warningsAsErrors: boolean;
8938            static lintEtsOnly: boolean;
8939            static totalVisitedNodes: number;
8940            static nodeCounters: number[];
8941            static lineCounters: number[];
8942            static totalErrorLines: number;
8943            static errorLineNumbersString: string;
8944            static totalWarningLines: number;
8945            static warningLineNumbersString: string;
8946            static reportDiagnostics: boolean;
8947            static problemsInfos: ProblemInfo[];
8948            static filteredDiagnosticMessages: DiagnosticMessageChain[];
8949            static initGlobals(): void;
8950            static initStatic(): void;
8951            static tsTypeChecker: TypeChecker;
8952            currentErrorLine: number;
8953            currentWarningLine: number;
8954            staticBlocks: Set<string>;
8955            libraryTypeCallDiagnosticChecker: LibraryTypeCallDiagnosticChecker;
8956            skipArkTSStaticBlocksCheck: boolean;
8957            constructor(sourceFile: SourceFile, tsProgram: Program, tscStrictDiagnostics?: Map<Diagnostic[]> | undefined);
8958            static clearTsTypeChecker(): void;
8959            readonly handlersMap: ESMap<SyntaxKind, (node: Node) => void>;
8960            incrementCounters(node: Node | CommentRange, faultId: number, autofixable?: boolean, autofix?: Autofix[]): void;
8961            visitTSNode(node: Node): void;
8962            private countInterfaceExtendsDifferentPropertyTypes;
8963            private countDeclarationsWithDuplicateName;
8964            private countClassMembersWithDuplicateName;
8965            private functionContainsThis;
8966            private isPrototypePropertyAccess;
8967            private interfaceInheritanceLint;
8968            private lintForInterfaceExtendsDifferentPorpertyTypes;
8969            private handleObjectLiteralExpression;
8970            private handleArrayLiteralExpression;
8971            private handleParameter;
8972            private handleEnumDeclaration;
8973            private handleInterfaceDeclaration;
8974            private handleThrowStatement;
8975            private handleForStatement;
8976            private handleForInStatement;
8977            private handleForOfStatement;
8978            private handleImportDeclaration;
8979            private handlePropertyAccessExpression;
8980            private handlePropertyAssignmentOrDeclaration;
8981            private filterOutDecoratorsDiagnostics;
8982            private checkInRange;
8983            private filterStrictDiagnostics;
8984            private handleFunctionExpression;
8985            private handleArrowFunction;
8986            private handleClassExpression;
8987            private handleFunctionDeclaration;
8988            private handleMissingReturnType;
8989            private hasLimitedTypeInferenceFromReturnExpr;
8990            private handlePrefixUnaryExpression;
8991            private handleBinaryExpression;
8992            private handleVariableDeclarationList;
8993            private handleVariableDeclaration;
8994            private handleEsObjectDelaration;
8995            private handleEsObjectAssignment;
8996            private handleCatchClause;
8997            private handleClassDeclaration;
8998            private handleModuleDeclaration;
8999            private handleTypeAliasDeclaration;
9000            private handleImportClause;
9001            private handleImportSpecifier;
9002            private handleNamespaceImport;
9003            private handleTypeAssertionExpression;
9004            private handleMethodDeclaration;
9005            private handleIdentifier;
9006            private isAllowedClassValueContext;
9007            private handleRestrictedValues;
9008            private identiferUseInValueContext;
9009            private isEnumPropAccess;
9010            private handleElementAccessExpression;
9011            private handleEnumMember;
9012            private handleExportAssignment;
9013            private handleCallExpression;
9014            private handleImportCall;
9015            private handleRequireCall;
9016            private handleGenericCallWithNoTypeArgs;
9017            private static listApplyBindCallApis;
9018            private handleFunctionApplyBindPropCall;
9019            private handleStructIdentAndUndefinedInArgs;
9020            private static LimitedApis;
9021            private handleStdlibAPICall;
9022            private findNonFilteringRangesFunctionCalls;
9023            private handleLibraryTypeCall;
9024            private handleNewExpression;
9025            private handleAsExpression;
9026            private handleTypeReference;
9027            private handleMetaProperty;
9028            private handleStructDeclaration;
9029            private handleSpreadOp;
9030            private handleConstructSignature;
9031            private handleComments;
9032            private handleExpressionWithTypeArguments;
9033            private handleComputedPropertyName;
9034            private checkErrorSuppressingAnnotation;
9035            private handleDecorators;
9036            private handleGetAccessor;
9037            private handleSetAccessor;
9038            private handleDeclarationInferredType;
9039            private handleDefiniteAssignmentAssertion;
9040            private validatedTypesSet;
9041            private checkAnyOrUnknownChildNode;
9042            private handleInferredObjectreference;
9043            private validateDeclInferredType;
9044            private handleClassStaticBlockDeclaration;
9045            lint(): void;
9046        }
9047    }
9048}
9049declare namespace ts {
9050    namespace ArkTSLinter_1_0 {
9051        class TSCCompiledProgram {
9052            private diagnosticsExtractor;
9053            constructor(program: BuilderProgram);
9054            getProgram(): Program;
9055            getBuilderProgram(): BuilderProgram;
9056            getStrictDiagnostics(fileName: string): Diagnostic[];
9057            doAllGetDiagnostics(): void;
9058        }
9059    }
9060}
9061declare namespace ts {
9062    namespace ArkTSLinter_1_0 {
9063        function translateDiag(srcFile: SourceFile, problemInfo: ProblemInfo): Diagnostic;
9064        function runArkTSLinter(tsBuilderProgram: BuilderProgram, srcFile?: SourceFile, buildInfoWriteFile?: WriteFileCallback, arkTSVersion?: string): Diagnostic[];
9065    }
9066}
9067declare namespace ts {
9068    namespace ArkTSLinter_1_1 {
9069        namespace Common {
9070            interface AutofixInfo {
9071                problemID: string;
9072                start: number;
9073                end: number;
9074            }
9075            interface CommandLineOptions {
9076                strictMode?: boolean;
9077                ideMode?: boolean;
9078                logTscErrors?: boolean;
9079                warningsAsErrors: boolean;
9080                parsedConfigFile?: ParsedCommandLine;
9081                inputFiles: string[];
9082                autofixInfo?: AutofixInfo[];
9083            }
9084            interface LintOptions {
9085                cmdOptions: CommandLineOptions;
9086                tsProgram?: Program;
9087                [key: string]: any;
9088            }
9089            enum ProblemSeverity {
9090                WARNING = 1,
9091                ERROR = 2
9092            }
9093        }
9094    }
9095}
9096declare namespace ts {
9097    namespace ArkTSLinter_1_1 {
9098        const cookBookMsg: string[];
9099        const cookBookTag: string[];
9100    }
9101}
9102declare namespace ts {
9103    namespace ArkTSLinter_1_1 {
9104        namespace DiagnosticCheckerNamespace {
9105            interface DiagnosticChecker {
9106                checkDiagnosticMessage(msgText: string | ts.DiagnosticMessageChain): boolean;
9107            }
9108        }
9109    }
9110}
9111declare namespace ts {
9112    namespace ArkTSLinter_1_1 {
9113        import DiagnosticChecker = DiagnosticCheckerNamespace.DiagnosticChecker;
9114        namespace LibraryTypeCallDiagnosticCheckerNamespace {
9115            const TYPE_0_IS_NOT_ASSIGNABLE_TO_TYPE_1_ERROR_CODE = 2322;
9116            const TYPE_UNKNOWN_IS_NOT_ASSIGNABLE_TO_TYPE_1_RE: RegExp;
9117            const TYPE_NULL_IS_NOT_ASSIGNABLE_TO_TYPE_1_RE: RegExp;
9118            const TYPE_UNDEFINED_IS_NOT_ASSIGNABLE_TO_TYPE_1_RE: RegExp;
9119            const ARGUMENT_OF_TYPE_0_IS_NOT_ASSIGNABLE_TO_PARAMETER_OF_TYPE_1_ERROR_CODE = 2345;
9120            const ARGUMENT_OF_TYPE_NULL_IS_NOT_ASSIGNABLE_TO_PARAMETER_OF_TYPE_1_RE: RegExp;
9121            const ARGUMENT_OF_TYPE_UNDEFINED_IS_NOT_ASSIGNABLE_TO_PARAMETER_OF_TYPE_1_RE: RegExp;
9122            const NO_OVERLOAD_MATCHES_THIS_CALL_ERROR_CODE = 2769;
9123            const TYPE = "Type";
9124            const IS_NOT_ASSIGNABLE_TO_TYPE = "is not assignable to type";
9125            const ARGUMENT_OF_TYPE = "Argument of type";
9126            const IS_NOT_ASSIGNABLE_TO_PARAMETER_OF_TYPE = "is not assignable to parameter of type";
9127            enum ErrorType {
9128                NO_ERROR = 0,
9129                UNKNOW = 1,
9130                NULL = 2,
9131                UNDEFINED = 3
9132            }
9133            class LibraryTypeCallDiagnosticChecker implements DiagnosticChecker {
9134                inLibCall: boolean;
9135                diagnosticMessages: Array<ts.DiagnosticMessageChain> | undefined;
9136                filteredDiagnosticMessages: DiagnosticMessageChain[];
9137                constructor(filteredDiagnosticMessages: DiagnosticMessageChain[]);
9138                configure(inLibCall: boolean, diagnosticMessages: Array<ts.DiagnosticMessageChain>): void;
9139                checkMessageText(msg: string): boolean;
9140                static checkMessageChain(chain: ts.DiagnosticMessageChain, inLibCall: boolean): ErrorType;
9141                checkFilteredDiagnosticMessages(msgText: ts.DiagnosticMessageChain | string): boolean;
9142                checkDiagnosticMessage(msgText: string | ts.DiagnosticMessageChain): boolean;
9143                static rebuildTscDiagnostics(tscStrictDiagnostics: Map<Diagnostic[]>): void;
9144                static collectDiagnosticMessage(diagnosticMessageChain: DiagnosticMessageChain, textSet: Set<string>): void;
9145            }
9146        }
9147    }
9148}
9149declare namespace ts {
9150    namespace ArkTSLinter_1_1 {
9151        namespace Problems {
9152            import ProblemSeverity = Common.ProblemSeverity;
9153            enum FaultID {
9154                AnyType = 0,
9155                SymbolType = 1,
9156                ObjectLiteralNoContextType = 2,
9157                ArrayLiteralNoContextType = 3,
9158                ComputedPropertyName = 4,
9159                LiteralAsPropertyName = 5,
9160                TypeQuery = 6,
9161                IsOperator = 7,
9162                DestructuringParameter = 8,
9163                YieldExpression = 9,
9164                InterfaceMerging = 10,
9165                EnumMerging = 11,
9166                InterfaceExtendsClass = 12,
9167                IndexMember = 13,
9168                WithStatement = 14,
9169                ThrowStatement = 15,
9170                IndexedAccessType = 16,
9171                UnknownType = 17,
9172                ForInStatement = 18,
9173                InOperator = 19,
9174                FunctionExpression = 20,
9175                IntersectionType = 21,
9176                ObjectTypeLiteral = 22,
9177                CommaOperator = 23,
9178                LimitedReturnTypeInference = 24,
9179                ClassExpression = 25,
9180                DestructuringAssignment = 26,
9181                DestructuringDeclaration = 27,
9182                VarDeclaration = 28,
9183                CatchWithUnsupportedType = 29,
9184                DeleteOperator = 30,
9185                DeclWithDuplicateName = 31,
9186                UnaryArithmNotNumber = 32,
9187                ConstructorType = 33,
9188                ConstructorIface = 34,
9189                ConstructorFuncs = 35,
9190                CallSignature = 36,
9191                TypeAssertion = 37,
9192                PrivateIdentifier = 38,
9193                LocalFunction = 39,
9194                ConditionalType = 40,
9195                MappedType = 41,
9196                NamespaceAsObject = 42,
9197                ClassAsObject = 43,
9198                NonDeclarationInNamespace = 44,
9199                GeneratorFunction = 45,
9200                FunctionContainsThis = 46,
9201                PropertyAccessByIndex = 47,
9202                JsxElement = 48,
9203                EnumMemberNonConstInit = 49,
9204                ImplementsClass = 50,
9205                MethodReassignment = 51,
9206                MultipleStaticBlocks = 52,
9207                ThisType = 53,
9208                IntefaceExtendDifProps = 54,
9209                StructuralIdentity = 55,
9210                ExportAssignment = 56,
9211                ImportAssignment = 57,
9212                GenericCallNoTypeArgs = 58,
9213                ParameterProperties = 59,
9214                InstanceofUnsupported = 60,
9215                ShorthandAmbientModuleDecl = 61,
9216                WildcardsInModuleName = 62,
9217                UMDModuleDefinition = 63,
9218                NewTarget = 64,
9219                DefiniteAssignment = 65,
9220                Prototype = 66,
9221                GlobalThis = 67,
9222                UtilityType = 68,
9223                PropertyDeclOnFunction = 69,
9224                FunctionApplyCall = 70,
9225                FunctionBind = 71,
9226                ConstAssertion = 72,
9227                ImportAssertion = 73,
9228                SpreadOperator = 74,
9229                LimitedStdLibApi = 75,
9230                ErrorSuppression = 76,
9231                StrictDiagnostic = 77,
9232                ImportAfterStatement = 78,
9233                EsObjectType = 79,
9234                SendableClassInheritance = 80,
9235                SendablePropType = 81,
9236                SendableDefiniteAssignment = 82,
9237                SendableGenericTypes = 83,
9238                SendableCapturedVars = 84,
9239                SendableClassDecorator = 85,
9240                SendableObjectInitialization = 86,
9241                SendableComputedPropName = 87,
9242                SendableAsExpr = 88,
9243                SharedNoSideEffectImport = 89,
9244                SharedModuleExports = 90,
9245                SharedModuleNoWildcardExport = 91,
9246                NoTsImportEts = 92,
9247                SendableTypeInheritance = 93,
9248                SendableTypeExported = 94,
9249                NoTsReExportEts = 95,
9250                NoNamespaceImportEtsToTs = 96,
9251                NoSideEffectImportEtsToTs = 97,
9252                SendableExplicitFieldType = 98,
9253                SendableFunctionImportedVariables = 99,
9254                SendableFunctionDecorator = 100,
9255                SendableTypeAliasDecorator = 101,
9256                SendableTypeAliasDeclaration = 102,
9257                SendableFunctionAssignment = 103,
9258                SendableFunctionOverloadDecorator = 104,
9259                SendableFunctionProperty = 105,
9260                SendableFunctionAsExpr = 106,
9261                SendableDecoratorLimited = 107,
9262                SendableClosureExport = 108,
9263                SharedModuleExportsWarning = 109,
9264                SendableBetaCompatible = 110,
9265                SendablePropTypeWarning = 111,
9266                LAST_ID = 112
9267            }
9268            class FaultAttributes {
9269                cookBookRef: number;
9270                migratable: boolean;
9271                severity: ProblemSeverity;
9272                constructor(cookBookRef: number, migratable?: boolean, severity?: ProblemSeverity);
9273            }
9274            const faultsAttrs: FaultAttributes[];
9275        }
9276    }
9277}
9278declare namespace ts {
9279    namespace ArkTSLinter_1_1 {
9280        import AutofixInfo = Common.AutofixInfo;
9281        namespace Utils {
9282            const PROPERTY_HAS_NO_INITIALIZER_ERROR_CODE = 2564;
9283            const NON_INITIALIZABLE_PROPERTY_DECORATORS: string[];
9284            const NON_INITIALIZABLE_PROPERTY_CLASS_DECORATORS: string[];
9285            const LIMITED_STANDARD_UTILITY_TYPES: string[];
9286            const ALLOWED_STD_SYMBOL_API: string[];
9287            const ARKTS_IGNORE_DIRS: string[];
9288            const ARKTS_IGNORE_FILES: string[];
9289            const SENDABLE_DECORATOR = "Sendable";
9290            const SENDABLE_INTERFACE = "ISendable";
9291            const SENDABLE_DECORATOR_NODES: SyntaxKind[];
9292            const SENDABLE_CLOSURE_DECLS: SyntaxKind[];
9293            const ARKTS_COLLECTIONS_D_ETS = "@arkts.collections.d.ets";
9294            const COLLECTIONS_NAMESPACE = "collections";
9295            const ARKTS_LANG_D_ETS = "@arkts.lang.d.ets";
9296            const LANG_NAMESPACE = "lang";
9297            const ISENDABLE_TYPE = "ISendable";
9298            const USE_SHARED = "use shared";
9299            const D_TS = ".d.ts";
9300            function setTypeChecker(tsTypeChecker: TypeChecker): void;
9301            function clearTypeChecker(): void;
9302            function setTestMode(tsTestMode: boolean): void;
9303            function getStartPos(nodeOrComment: Node | CommentRange): number;
9304            function getEndPos(nodeOrComment: Node | CommentRange): number;
9305            function getHighlightRange(nodeOrComment: Node | CommentRange, faultId: number): [number, number];
9306            function getVarDeclarationHighlightRange(nodeOrComment: Node | CommentRange): [number, number] | undefined;
9307            function getCatchWithUnsupportedTypeHighlightRange(nodeOrComment: Node | CommentRange): [number, number] | undefined;
9308            function getForInStatementHighlightRange(nodeOrComment: Node | CommentRange): [number, number] | undefined;
9309            function getWithStatementHighlightRange(nodeOrComment: Node | CommentRange): [number, number] | undefined;
9310            function getDeleteOperatorHighlightRange(nodeOrComment: Node | CommentRange): [number, number] | undefined;
9311            function getTypeQueryHighlightRange(nodeOrComment: Node | CommentRange): [number, number] | undefined;
9312            function getInstanceofUnsupportedHighlightRange(nodeOrComment: Node | CommentRange): [number, number] | undefined;
9313            function getConstAssertionHighlightRange(nodeOrComment: Node | CommentRange): [number, number] | undefined;
9314            function getLimitedReturnTypeInferenceHighlightRange(nodeOrComment: Node | CommentRange): [number, number] | undefined;
9315            function getLocalFunctionHighlightRange(nodeOrComment: Node | CommentRange): [number, number] | undefined;
9316            function getFunctionApplyCallHighlightRange(nodeOrComment: Node | CommentRange): [number, number] | undefined;
9317            function getDeclWithDuplicateNameHighlightRange(nodeOrComment: Node | CommentRange): [number, number] | undefined;
9318            function getObjectLiteralNoContextTypeHighlightRange(nodeOrComment: Node | CommentRange): [number, number] | undefined;
9319            function getClassExpressionHighlightRange(nodeOrComment: Node | CommentRange): [number, number] | undefined;
9320            function getMultipleStaticBlocksHighlightRange(nodeOrComment: ts.Node | ts.CommentRange): [number, number] | undefined;
9321            function getSendableDefiniteAssignmentHighlightRange(nodeOrComment: ts.Node | ts.CommentRange): [number, number] | undefined;
9322            function getKeywordHighlightRange(nodeOrComment: Node | CommentRange, keyword: string): [number, number];
9323            function isAssignmentOperator(tsBinOp: BinaryOperatorToken): boolean;
9324            function isType(tsType: TypeNode | undefined, checkType: string): boolean;
9325            function entityNameToString(name: EntityName): string;
9326            function isNumberLikeType(tsType: Type): boolean;
9327            function isBooleanLikeType(tsType: Type): boolean;
9328            function isStringLikeType(tsType: Type): boolean;
9329            function isStringType(tsType: ts.Type): boolean;
9330            function isPrimitiveEnumMemberType(type: Type, primitiveType: TypeFlags): boolean;
9331            function unwrapParenthesizedType(tsType: TypeNode): TypeNode;
9332            function findParentIf(asExpr: AsExpression): IfStatement | null;
9333            function isDestructuringAssignmentLHS(tsExpr: ArrayLiteralExpression | ObjectLiteralExpression): boolean;
9334            function isEnumType(tsType: ts.Type): boolean;
9335            function isEnum(tsSymbol: ts.Symbol): boolean;
9336            function isEnumMemberType(tsType: Type): boolean;
9337            function isObjectLiteralType(tsType: Type): boolean;
9338            function hasModifier(tsModifiers: readonly Modifier[] | undefined, tsModifierKind: number): boolean;
9339            function unwrapParenthesized(tsExpr: Expression): Expression;
9340            function followIfAliased(sym: Symbol): Symbol;
9341            function trueSymbolAtLocation(node: Node): Symbol | undefined;
9342            function clearTrueSymbolAtLocationCache(): void;
9343            function isTypeDeclSyntaxKind(kind: SyntaxKind): boolean;
9344            function symbolHasDuplicateName(symbol: Symbol, tsDeclKind: SyntaxKind): boolean;
9345            function isReferenceType(tsType: Type): boolean;
9346            function isPrimitiveType(type: Type): boolean;
9347            function isPrimitiveLiteralType(type: ts.Type): boolean;
9348            function isPurePrimitiveLiteralType(type: ts.Type): boolean;
9349            function isTypeSymbol(symbol: Symbol | undefined): boolean;
9350            function isGenericArrayType(tsType: Type): tsType is TypeReference;
9351            function isReadonlyArrayType(tsType: Type): boolean;
9352            function isTypedArray(tsType: ts.Type): boolean;
9353            function isArray(tsType: ts.Type): boolean;
9354            function isTuple(tsType: ts.Type): boolean;
9355            function isOrDerivedFrom(tsType: ts.Type, checkType: CheckType, checkedBaseTypes?: Set<ts.Type>): boolean;
9356            function isTypeReference(tsType: Type): tsType is TypeReference;
9357            function isNullType(tsTypeNode: TypeNode): boolean;
9358            function isThisOrSuperExpr(tsExpr: Expression): boolean;
9359            function isPrototypeSymbol(symbol: Symbol | undefined): boolean;
9360            function isFunctionSymbol(symbol: Symbol | undefined): boolean;
9361            function isInterfaceType(tsType: Type | undefined): boolean;
9362            function isAnyType(tsType: Type): tsType is TypeReference;
9363            function isUnknownType(tsType: Type): boolean;
9364            function isUnsupportedType(tsType: Type): boolean;
9365            function isUnsupportedUnionType(tsType: Type): boolean;
9366            function isFunctionOrMethod(tsSymbol: Symbol | undefined): boolean;
9367            function isMethodAssignment(tsSymbol: Symbol | undefined): boolean;
9368            function getDeclaration(tsSymbol: ts.Symbol | undefined): ts.Declaration | undefined;
9369            function isValidEnumMemberInit(tsExpr: Expression): boolean;
9370            function isCompileTimeExpression(tsExpr: Expression): boolean;
9371            function isConst(tsNode: Node): boolean;
9372            function isNumberConstantValue(tsExpr: EnumMember | PropertyAccessExpression | ElementAccessExpression | NumericLiteral): boolean;
9373            function isIntegerConstantValue(tsExpr: EnumMember | PropertyAccessExpression | ElementAccessExpression | NumericLiteral): boolean;
9374            function isStringConstantValue(tsExpr: EnumMember | PropertyAccessExpression | ElementAccessExpression): boolean;
9375            function relatedByInheritanceOrIdentical(typeA: Type, typeB: Type): boolean;
9376            function reduceReference(t: ts.Type): ts.Type;
9377            function needToDeduceStructuralIdentity(lhsType: Type, rhsType: Type, rhsExpr: Expression, isStrict?: boolean): boolean;
9378            function needStrictMatchType(lhsType: ts.Type, rhsType: ts.Type): boolean;
9379            function hasPredecessor(node: Node, predicate: (node: Node) => boolean): boolean;
9380            function processParentTypes(parentTypes: NodeArray<ExpressionWithTypeArguments>, typeB: Type, processInterfaces: boolean): boolean;
9381            function isObject(tsType: Type): boolean;
9382            function logTscDiagnostic(diagnostics: readonly Diagnostic[], log: (message: any, ...args: any[]) => void): void;
9383            function encodeProblemInfo(problem: ProblemInfo): string;
9384            function decodeAutofixInfo(info: string): AutofixInfo;
9385            function isCallToFunctionWithOmittedReturnType(tsExpr: Expression): boolean;
9386            function validateObjectLiteralType(type: Type | undefined): boolean;
9387            function isStructDeclarationKind(kind: SyntaxKind): boolean;
9388            function isStructDeclaration(node: Node): boolean;
9389            function isStructObjectInitializer(objectLiteral: ObjectLiteralExpression): boolean;
9390            function hasMethods(type: Type): boolean;
9391            function checkTypeSet(typeSet: ts.Type, predicate: CheckType): boolean;
9392            function getNonNullableType(t: ts.Type): ts.Type;
9393            function isObjectLiteralAssignable(lhsType: ts.Type | undefined, rhsExpr: ts.ObjectLiteralExpression): boolean;
9394            function isLiteralType(type: Type): boolean;
9395            function validateFields(objectType: Type, objectLiteral: ObjectLiteralExpression): boolean;
9396            function isSupportedType(typeNode: TypeNode): boolean;
9397            function isStruct(symbol: Symbol): boolean;
9398            type CheckType = ((t: Type) => boolean);
9399            const ES_OBJECT = "ESObject";
9400            const LIMITED_STD_GLOBAL_FUNC: string[];
9401            const LIMITED_STD_OBJECT_API: string[];
9402            const LIMITED_STD_REFLECT_API: string[];
9403            const LIMITED_STD_PROXYHANDLER_API: string[];
9404            const FUNCTION_HAS_NO_RETURN_ERROR_CODE = 2366;
9405            const NON_RETURN_FUNCTION_DECORATORS: string[];
9406            const STANDARD_LIBRARIES: string[];
9407            const TYPED_ARRAYS: string[];
9408            function getParentSymbolName(symbol: Symbol): string | undefined;
9409            function isGlobalSymbol(symbol: Symbol): boolean;
9410            function isSymbolAPI(symbol: Symbol): boolean;
9411            function isStdSymbol(symbol: ts.Symbol): boolean;
9412            function isSymbolIterator(symbol: ts.Symbol): boolean;
9413            function isSymbolIteratorExpression(expr: ts.Expression): boolean;
9414            function isDefaultImport(importSpec: ImportSpecifier): boolean;
9415            function hasAccessModifier(decl: Declaration): boolean;
9416            function getModifier(modifiers: readonly Modifier[] | undefined, modifierKind: SyntaxKind): Modifier | undefined;
9417            function getAccessModifier(modifiers: readonly Modifier[] | undefined): Modifier | undefined;
9418            function isStdRecordType(type: Type): boolean;
9419            function isStdMapType(type: Type): boolean;
9420            function isStdErrorType(type: ts.Type): boolean;
9421            function isStdPartialType(type: Type): boolean;
9422            function isStdRequiredType(type: Type): boolean;
9423            function isStdReadonlyType(type: Type): boolean;
9424            function isLibraryType(type: Type): boolean;
9425            function hasLibraryType(node: Node): boolean;
9426            function isLibrarySymbol(sym: Symbol | undefined): boolean;
9427            function srcFilePathContainsDirectory(srcFile: SourceFile, dir: string): boolean;
9428            function pathContainsDirectory(targetPath: string, dir: string): boolean;
9429            function getScriptKind(srcFile: SourceFile): ScriptKind;
9430            function isStdLibraryType(type: Type): boolean;
9431            function isStdLibrarySymbol(sym: Symbol | undefined): boolean;
9432            function isIntrinsicObjectType(type: Type): boolean;
9433            function isDynamicType(type: Type | undefined): boolean | undefined;
9434            function isObjectType(type: ts.Type): type is ts.ObjectType;
9435            function isAnonymous(type: ts.Type): boolean;
9436            function isDynamicLiteralInitializer(expr: Expression): boolean;
9437            function isEsObjectType(typeNode: ts.TypeNode | undefined): boolean;
9438            function isInsideBlock(node: ts.Node): boolean;
9439            function isEsObjectPossiblyAllowed(typeRef: ts.TypeReferenceNode): boolean;
9440            function isValueAssignableToESObject(node: ts.Node): boolean;
9441            function getVariableDeclarationTypeNode(node: Node): TypeNode | undefined;
9442            function getSymbolDeclarationTypeNode(sym: ts.Symbol): ts.TypeNode | undefined;
9443            function hasEsObjectType(node: Node): boolean;
9444            function symbolHasEsObjectType(sym: ts.Symbol): boolean;
9445            function isEsObjectSymbol(sym: Symbol): boolean;
9446            function isAnonymousType(type: Type): boolean;
9447            function getSymbolOfCallExpression(callExpr: CallExpression): Symbol | undefined;
9448            function typeIsRecursive(topType: Type, type?: Type | undefined): boolean;
9449            function getTypeOrTypeConstraintAtLocation(expr: ts.Expression): ts.Type;
9450            function isStdBigIntType(type: ts.Type): boolean;
9451            function isStdNumberType(type: ts.Type): boolean;
9452            function isStdBooleanType(type: ts.Type): boolean;
9453            function isEnumStringLiteral(expr: ts.Expression): boolean;
9454            function isValidComputedPropertyName(computedProperty: ComputedPropertyName, isRecordObjectInitializer?: boolean): boolean;
9455            function isAllowedIndexSignature(node: ts.IndexSignatureDeclaration): boolean;
9456            function isArkTSCollectionsArrayLikeType(type: ts.Type): boolean;
9457            function isArkTSCollectionsClassOrInterfaceDeclaration(decl: ts.Node): boolean;
9458            function getDecoratorName(decorator: ts.Decorator): string;
9459            function unwrapParenthesizedTypeNode(typeNode: ts.TypeNode): ts.TypeNode;
9460            function isSendableTypeNode(typeNode: ts.TypeNode, isShared?: boolean): boolean;
9461            function isSendableType(type: ts.Type): boolean;
9462            function isShareableType(tsType: ts.Type): boolean;
9463            function isSendableClassOrInterface(type: ts.Type): boolean;
9464            function typeContainsSendableClassOrInterface(type: ts.Type): boolean;
9465            function typeContainsNonSendableClassOrInterface(type: ts.Type): boolean;
9466            function isConstEnum(sym: ts.Symbol | undefined): boolean;
9467            function isSendableUnionType(type: ts.UnionType): boolean;
9468            function hasSendableDecorator(decl: ts.ClassDeclaration | ts.FunctionDeclaration | ts.TypeAliasDeclaration): boolean;
9469            function getNonSendableDecorators(decl: ts.ClassDeclaration | ts.FunctionDeclaration | ts.TypeAliasDeclaration): ts.Decorator[] | undefined;
9470            function getSendableDecorator(decl: ts.ClassDeclaration | ts.FunctionDeclaration | ts.TypeAliasDeclaration): ts.Decorator | undefined;
9471            function getDecoratorsIfInSendableClass(declaration: ts.HasDecorators): readonly ts.Decorator[] | undefined;
9472            function isISendableInterface(type: ts.Type): boolean;
9473            function isSharedModule(sourceFile: ts.SourceFile): boolean;
9474            function getDeclarationNode(node: ts.Node): ts.Declaration | undefined;
9475            function isShareableEntity(node: ts.Node): boolean;
9476            function isSendableClassOrInterfaceEntity(node: ts.Node): boolean;
9477            function isInImportWhiteList(resolvedModule: ResolvedModuleFull): boolean;
9478            function hasSendableDecoratorFunctionOverload(decl: ts.FunctionDeclaration): boolean;
9479            function isSendableFunction(type: ts.Type): boolean;
9480            function isSendableTypeAlias(type: ts.Type): boolean;
9481            function hasSendableTypeAlias(type: ts.Type): boolean;
9482            function isNonSendableFunctionTypeAlias(type: ts.Type): boolean;
9483            function isWrongSendableFunctionAssignment(lhsType: ts.Type, rhsType: ts.Type): boolean;
9484            function searchFileExportDecl(sourceFile: ts.SourceFile, targetDecls?: ts.SyntaxKind[]): Set<ts.Node>;
9485            function normalizePath(path: string): string;
9486            function clearUtilsGlobalvariables(): void;
9487        }
9488    }
9489}
9490declare namespace ts {
9491    namespace ArkTSLinter_1_1 {
9492        namespace Autofixer {
9493            import AutofixInfo = Common.AutofixInfo;
9494            import FaultID = Problems.FaultID;
9495            const AUTOFIX_ALL: AutofixInfo;
9496            const autofixInfo: AutofixInfo[];
9497            function shouldAutofix(node: Node, faultID: FaultID): boolean;
9498            interface Autofix {
9499                replacementText: string;
9500                start: number;
9501                end: number;
9502            }
9503            function fixLiteralAsPropertyName(node: Node): Autofix[] | undefined;
9504            function fixPropertyAccessByIndex(node: Node): Autofix[] | undefined;
9505            function fixFunctionExpression(funcExpr: FunctionExpression, params?: NodeArray<ParameterDeclaration>, retType?: TypeNode | undefined): Autofix;
9506            function fixReturnType(funcLikeDecl: FunctionLikeDeclaration, typeNode: TypeNode): Autofix;
9507            function fixCtorParameterProperties(ctorDecl: ConstructorDeclaration, paramTypes: TypeNode[]): Autofix[] | undefined;
9508        }
9509    }
9510}
9511declare namespace ts {
9512    namespace ArkTSLinter_1_1 {
9513        import FaultID = Problems.FaultID;
9514        class LinterConfig {
9515            static nodeDesc: string[];
9516            static tsSyntaxKindNames: string[];
9517            static initStatic(): void;
9518            static terminalTokens: Set<SyntaxKind>;
9519            static incrementOnlyTokens: ESMap<SyntaxKind, FaultID>;
9520        }
9521    }
9522}
9523declare namespace ts {
9524    namespace ArkTSLinter_1_1 {
9525        import Autofix = Autofixer.Autofix;
9526        import LibraryTypeCallDiagnosticChecker = LibraryTypeCallDiagnosticCheckerNamespace.LibraryTypeCallDiagnosticChecker;
9527        interface ProblemInfo {
9528            line: number;
9529            column: number;
9530            start: number;
9531            end: number;
9532            type: string;
9533            severity: number;
9534            problem: string;
9535            suggest: string;
9536            rule: string;
9537            ruleTag: number;
9538            autofixable: boolean;
9539            autofix?: Autofix[];
9540        }
9541        class TypeScriptLinter {
9542            private sourceFile;
9543            private tscStrictDiagnostics?;
9544            static ideMode: boolean;
9545            static strictMode: boolean;
9546            static logTscErrors: boolean;
9547            static warningsAsErrors: boolean;
9548            static lintEtsOnly: boolean;
9549            static totalVisitedNodes: number;
9550            static nodeCounters: number[];
9551            static lineCounters: number[];
9552            static totalErrorLines: number;
9553            static errorLineNumbersString: string;
9554            static totalWarningLines: number;
9555            static warningLineNumbersString: string;
9556            static reportDiagnostics: boolean;
9557            static problemsInfos: ProblemInfo[];
9558            static filteredDiagnosticMessages: DiagnosticMessageChain[];
9559            static sharedModulesCache: ESMap<string, boolean>;
9560            static strictDiagnosticCache: Set<Diagnostic>;
9561            static unknowDiagnosticCache: Set<Diagnostic>;
9562            static initGlobals(): void;
9563            static initStatic(): void;
9564            static tsTypeChecker: TypeChecker;
9565            currentErrorLine: number;
9566            currentWarningLine: number;
9567            staticBlocks: Set<string>;
9568            libraryTypeCallDiagnosticChecker: LibraryTypeCallDiagnosticChecker;
9569            skipArkTSStaticBlocksCheck: boolean;
9570            private fileExportSendableDeclCaches?;
9571            private compatibleSdkVersionStage;
9572            private compatibleSdkVersion;
9573            constructor(sourceFile: SourceFile, tsProgram: Program, tscStrictDiagnostics?: Map<Diagnostic[]> | undefined);
9574            static clearTsTypeChecker(): void;
9575            readonly handlersMap: ESMap<SyntaxKind, (node: Node) => void>;
9576            incrementCounters(node: Node | CommentRange, faultId: number, autofixable?: boolean, autofix?: Autofix[]): void;
9577            private forEachNodeInSubtree;
9578            private visitSourceFile;
9579            private countInterfaceExtendsDifferentPropertyTypes;
9580            private countDeclarationsWithDuplicateName;
9581            private countClassMembersWithDuplicateName;
9582            private static scopeContainsThis;
9583            private isPrototypePropertyAccess;
9584            private interfaceInheritanceLint;
9585            private lintForInterfaceExtendsDifferentPorpertyTypes;
9586            private handleObjectLiteralExpression;
9587            private handleArrayLiteralExpression;
9588            private handleParameter;
9589            private handleEnumDeclaration;
9590            private handleInterfaceDeclaration;
9591            private handleThrowStatement;
9592            private handleForStatement;
9593            private handleForInStatement;
9594            private handleForOfStatement;
9595            private handleImportDeclaration;
9596            private handleSharedModuleNoSideEffectImport;
9597            private static inSharedModule;
9598            private handlePropertyAccessExpression;
9599            private handlePropertyDeclaration;
9600            private handleSendableClassProperty;
9601            private checkTypeAliasInSendableScope;
9602            private isNoneSendableTypeAlias;
9603            private handlePropertyAssignment;
9604            private handlePropertySignature;
9605            private handleSendableInterfaceProperty;
9606            private filterOutDecoratorsDiagnostics;
9607            private checkInRange;
9608            private filterStrictDiagnostics;
9609            private static isClassLikeOrIface;
9610            private handleFunctionExpression;
9611            private handleArrowFunction;
9612            private handleFunctionDeclaration;
9613            private handleMissingReturnType;
9614            private hasLimitedTypeInferenceFromReturnExpr;
9615            private isValidTypeForUnaryArithmeticOperator;
9616            private handlePrefixUnaryExpression;
9617            private handleBinaryExpression;
9618            private handleVariableDeclarationList;
9619            private handleVariableDeclaration;
9620            private handleEsObjectDelaration;
9621            private handleEsObjectAssignment;
9622            private handleCatchClause;
9623            private handleClassDeclaration;
9624            private scanCapturedVarsInSendableScope;
9625            private checkLocalDecl;
9626            private checkLocalDeclWithSendableClosure;
9627            private checkIsTopClosure;
9628            private checkNamespaceImportVar;
9629            isFileExportSendableDecl(decl: ts.Declaration): boolean;
9630            private checkClassDeclarationHeritageClause;
9631            private isValidSendableClassExtends;
9632            private checkSendableTypeParameter;
9633            private processClassStaticBlocks;
9634            private handleModuleDeclaration;
9635            private handleTypeAliasDeclaration;
9636            private handleImportClause;
9637            private handleImportSpecifier;
9638            private handleNamespaceImport;
9639            private handleTypeAssertionExpression;
9640            private handleMethodDeclaration;
9641            private handleMethodSignature;
9642            private handleIdentifier;
9643            private isAllowedClassValueContext;
9644            private handleRestrictedValues;
9645            private identiferUseInValueContext;
9646            private isEnumPropAccess;
9647            private isElementAcessAllowed;
9648            private handleElementAccessExpression;
9649            private handleEnumMember;
9650            private handleExportAssignment;
9651            private handleCallExpression;
9652            private handleEtsComponentExpression;
9653            private handleImportCall;
9654            private handleRequireCall;
9655            private handleGenericCallWithNoTypeArgs;
9656            private static readonly listFunctionApplyCallApis;
9657            private static readonly listFunctionBindApis;
9658            private handleFunctionApplyBindPropCall;
9659            private handleStructIdentAndUndefinedInArgs;
9660            private static LimitedApis;
9661            private handleStdlibAPICall;
9662            private findNonFilteringRangesFunctionCalls;
9663            private handleLibraryTypeCall;
9664            private handleNewExpression;
9665            private handleSendableGenericTypes;
9666            private handleAsExpression;
9667            private handleTypeReference;
9668            private checkSendableTypeArguments;
9669            private handleMetaProperty;
9670            private handleSpreadOp;
9671            private handleConstructSignature;
9672            private handleExpressionWithTypeArguments;
9673            private handleComputedPropertyName;
9674            private isSendableCompPropName;
9675            private handleGetAccessor;
9676            private handleSetAccessor;
9677            private handleDeclarationInferredType;
9678            private handleDefiniteAssignmentAssertion;
9679            private validatedTypesSet;
9680            private checkAnyOrUnknownChildNode;
9681            private handleInferredObjectreference;
9682            private validateDeclInferredType;
9683            private processNoCheckEntry;
9684            private reportThisKeywordsInScope;
9685            private handleCommentDirectives;
9686            private handleClassStaticBlockDeclaration;
9687            private handleIndexSignature;
9688            lint(): void;
9689            private handleExportKeyword;
9690            private handleExportDeclaration;
9691            private handleReturnStatement;
9692            /**
9693             * 'arkts-no-structural-typing' check was missing in some scenarios,
9694             * in order not to cause incompatibility,
9695             * only need to strictly match the type of filling the check again
9696             */
9697            private checkAssignmentMatching;
9698            private handleDecorator;
9699            private isSendableDecoratorValid;
9700        }
9701    }
9702}
9703declare namespace ts {
9704    namespace ArkTSLinter_1_1 {
9705        import Autofix = Autofixer.Autofix;
9706        interface KitSymbol {
9707            source: string;
9708            bindings: string;
9709        }
9710        type KitSymbols = Record<string, KitSymbol>;
9711        interface KitInfo {
9712            symbols?: KitSymbols;
9713        }
9714        class InteropTypescriptLinter {
9715            private sourceFile;
9716            private isInSdk;
9717            static strictMode: boolean;
9718            static totalVisitedNodes: number;
9719            static nodeCounters: number[];
9720            static lineCounters: number[];
9721            static totalErrorLines: number;
9722            static errorLineNumbersString: string;
9723            static totalWarningLines: number;
9724            static warningLineNumbersString: string;
9725            static reportDiagnostics: boolean;
9726            static problemsInfos: ProblemInfo[];
9727            static initGlobals(): void;
9728            static initStatic(): void;
9729            static tsTypeChecker: TypeChecker;
9730            static etsLoaderPath?: string;
9731            static kitInfos: Map<KitInfo>;
9732            private KIT;
9733            private D_TS;
9734            private D_ETS;
9735            private ETS;
9736            private SDK_PATH;
9737            currentErrorLine: number;
9738            currentWarningLine: number;
9739            constructor(sourceFile: SourceFile, tsProgram: Program, isInSdk: boolean);
9740            static clearTsTypeChecker(): void;
9741            readonly handlersMap: ESMap<SyntaxKind, (node: Node) => void>;
9742            incrementCounters(node: Node | CommentRange, faultId: number, autofixable?: boolean, autofix?: Autofix[]): void;
9743            private forEachNodeInSubtree;
9744            private visitSourceFile;
9745            private handleImportDeclaration;
9746            private checkSendableClassorISendable;
9747            private checkKitImportClause;
9748            private checkImportClause;
9749            private allowInSdkImportSendable;
9750            private handleClassDeclaration;
9751            private checkClassOrInterfaceDeclarationHeritageClause;
9752            private handleInterfaceDeclaration;
9753            private handleNewExpression;
9754            private handleSendableGenericTypes;
9755            private handleObjectLiteralExpression;
9756            private handleArrayLiteralExpression;
9757            private handleAsExpression;
9758            private handleExportDeclaration;
9759            private handleExportAssignment;
9760            private initKitInfos;
9761            private getKitModuleFileNames;
9762            lint(): void;
9763        }
9764    }
9765}
9766declare namespace ts {
9767    namespace ArkTSLinter_1_1 {
9768        class TSCCompiledProgram {
9769            private diagnosticsExtractor;
9770            constructor(program: BuilderProgram);
9771            getProgram(): Program;
9772            getBuilderProgram(): BuilderProgram;
9773            getStrictDiagnostics(sourceFile: SourceFile): Diagnostic[];
9774            doAllGetDiagnostics(): void;
9775        }
9776    }
9777}
9778declare namespace ts {
9779    namespace ArkTSLinter_1_1 {
9780        function translateDiag(srcFile: SourceFile, problemInfo: ProblemInfo): Diagnostic;
9781        function runArkTSLinter(tsBuilderProgram: BuilderProgram, srcFile?: SourceFile, buildInfoWriteFile?: WriteFileCallback, arkTSVersion?: string): Diagnostic[];
9782    }
9783}
9784declare namespace ts {
9785    enum TimePhase {
9786        START = "start",
9787        GET_PROGRAM = "getProgram(not ArkTSLinter)",
9788        UPDATE_ERROR_FILE = "updateErrorFile",
9789        INIT = "init",
9790        STRICT_PROGRAM_GET_SEMANTIC_DIAGNOSTICS = "strictProgramGetSemanticDiagnostics",
9791        NON_STRICT_PROGRAM_GET_SEMANTIC_DIAGNOSTICS = "nonStrictProgramGetSemanticDiagnostics",
9792        NON_STRICT_PROGRAM_GET_SYNTACTIC_DIAGNOSTICS = "nonStrictProgramGetSyntacticDiagnostics",
9793        GET_TSC_DIAGNOSTICS = "getTscDiagnostics",
9794        EMIT_BUILD_INFO = "emitBuildInfo",
9795        LINT = "lint"
9796    }
9797    class ArkTSLinterTimePrinter {
9798        private static instance?;
9799        private arkTSTimePrintSwitch;
9800        private timeMap;
9801        private constructor();
9802        static getInstance(): ArkTSLinterTimePrinter;
9803        static destroyInstance(): void;
9804        setArkTSTimePrintSwitch(arkTSTimePrintSwitch: boolean): void;
9805        appendTime(key: string): void;
9806        private formatMapAsTable;
9807        printTimes(): void;
9808    }
9809}
9810