@typescript-eslint/utils 6.4.1-alpha.11 → 6.4.1-alpha.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (33) hide show
  1. package/_ts4.3/dist/ast-utils/eslint-utils/PatternMatcher.d.ts +48 -0
  2. package/_ts4.3/dist/ast-utils/eslint-utils/ReferenceTracker.d.ts +76 -0
  3. package/_ts4.3/dist/ast-utils/eslint-utils/astUtilities.d.ts +76 -0
  4. package/_ts4.3/dist/ast-utils/eslint-utils/index.d.ts +6 -0
  5. package/_ts4.3/dist/ast-utils/eslint-utils/predicates.d.ts +32 -0
  6. package/_ts4.3/dist/ast-utils/eslint-utils/scopeAnalysis.d.ts +18 -0
  7. package/_ts4.3/dist/ast-utils/helpers.d.ts +1207 -0
  8. package/_ts4.3/dist/ast-utils/index.d.ts +5 -0
  9. package/_ts4.3/dist/ast-utils/misc.d.ts +8 -0
  10. package/_ts4.3/dist/ast-utils/predicates.d.ts +70 -0
  11. package/_ts4.3/dist/eslint-utils/InferTypesFromRule.d.ts +11 -0
  12. package/_ts4.3/dist/eslint-utils/RuleCreator.d.ts +35 -0
  13. package/_ts4.3/dist/eslint-utils/applyDefault.d.ts +10 -0
  14. package/_ts4.3/dist/eslint-utils/deepMerge.d.ts +17 -0
  15. package/_ts4.3/dist/eslint-utils/getParserServices.d.ts +24 -0
  16. package/_ts4.3/dist/eslint-utils/index.d.ts +7 -0
  17. package/_ts4.3/dist/eslint-utils/nullThrows.d.ts +14 -0
  18. package/_ts4.3/dist/index.d.ts +8 -0
  19. package/_ts4.3/dist/json-schema.d.ts +388 -0
  20. package/_ts4.3/dist/ts-eslint/AST.d.ts +9 -0
  21. package/_ts4.3/dist/ts-eslint/CLIEngine.d.ts +131 -0
  22. package/_ts4.3/dist/ts-eslint/ESLint.d.ts +376 -0
  23. package/_ts4.3/dist/ts-eslint/Linter.d.ts +327 -0
  24. package/_ts4.3/dist/ts-eslint/ParserOptions.d.ts +2 -0
  25. package/_ts4.3/dist/ts-eslint/Rule.d.ts +418 -0
  26. package/_ts4.3/dist/ts-eslint/RuleTester.d.ts +161 -0
  27. package/_ts4.3/dist/ts-eslint/Scope.d.ts +44 -0
  28. package/_ts4.3/dist/ts-eslint/SourceCode.d.ts +344 -0
  29. package/_ts4.3/dist/ts-eslint/index.d.ts +10 -0
  30. package/_ts4.3/dist/ts-estree.d.ts +3 -0
  31. package/_ts4.3/dist/ts-utils/index.d.ts +2 -0
  32. package/_ts4.3/dist/ts-utils/isArray.d.ts +2 -0
  33. package/package.json +6 -6
package/_ts4.3/dist/ast-utils/helpers.d.ts ADDED
@@ -0,0 +1,1207 @@
1
+ import type { AST_NODE_TYPES, AST_TOKEN_TYPES, TSESTree } from '../ts-estree';
2
+ export declare const isNodeOfType: <NodeType extends AST_NODE_TYPES>(nodeType: NodeType) => (node: TSESTree.Node | null | undefined) => node is Extract<TSESTree.AccessorPropertyComputedName, {
3
+ type: NodeType;
4
+ }> | Extract<TSESTree.AccessorPropertyNonComputedName, {
5
+ type: NodeType;
6
+ }> | Extract<TSESTree.ArrayExpression, {
7
+ type: NodeType;
8
+ }> | Extract<TSESTree.ArrayPattern, {
9
+ type: NodeType;
10
+ }> | Extract<TSESTree.ArrowFunctionExpression, {
11
+ type: NodeType;
12
+ }> | Extract<TSESTree.AssignmentExpression, {
13
+ type: NodeType;
14
+ }> | Extract<TSESTree.AssignmentPattern, {
15
+ type: NodeType;
16
+ }> | Extract<TSESTree.AwaitExpression, {
17
+ type: NodeType;
18
+ }> | Extract<TSESTree.BinaryExpression, {
19
+ type: NodeType;
20
+ }> | Extract<TSESTree.BlockStatement, {
21
+ type: NodeType;
22
+ }> | Extract<TSESTree.BreakStatement, {
23
+ type: NodeType;
24
+ }> | Extract<TSESTree.CallExpression, {
25
+ type: NodeType;
26
+ }> | Extract<TSESTree.CatchClause, {
27
+ type: NodeType;
28
+ }> | Extract<TSESTree.ChainExpression, {
29
+ type: NodeType;
30
+ }> | Extract<TSESTree.ClassBody, {
31
+ type: NodeType;
32
+ }> | Extract<TSESTree.ClassDeclarationWithName, {
33
+ type: NodeType;
34
+ }> | Extract<TSESTree.ClassDeclarationWithOptionalName, {
35
+ type: NodeType;
36
+ }> | Extract<TSESTree.ClassExpression, {
37
+ type: NodeType;
38
+ }> | Extract<TSESTree.ConditionalExpression, {
39
+ type: NodeType;
40
+ }> | Extract<TSESTree.ContinueStatement, {
41
+ type: NodeType;
42
+ }> | Extract<TSESTree.DebuggerStatement, {
43
+ type: NodeType;
44
+ }> | Extract<TSESTree.Decorator, {
45
+ type: NodeType;
46
+ }> | Extract<TSESTree.DoWhileStatement, {
47
+ type: NodeType;
48
+ }> | Extract<TSESTree.EmptyStatement, {
49
+ type: NodeType;
50
+ }> | Extract<TSESTree.ExportAllDeclaration, {
51
+ type: NodeType;
52
+ }> | Extract<TSESTree.ExportDefaultDeclaration, {
53
+ type: NodeType;
54
+ }> | Extract<TSESTree.ExportNamedDeclarationWithoutSourceWithMultiple, {
55
+ type: NodeType;
56
+ }> | Extract<TSESTree.ExportNamedDeclarationWithoutSourceWithSingle, {
57
+ type: NodeType;
58
+ }> | Extract<TSESTree.ExportNamedDeclarationWithSource, {
59
+ type: NodeType;
60
+ }> | Extract<TSESTree.ExportSpecifier, {
61
+ type: NodeType;
62
+ }> | Extract<TSESTree.ExpressionStatement, {
63
+ type: NodeType;
64
+ }> | Extract<TSESTree.ForInStatement, {
65
+ type: NodeType;
66
+ }> | Extract<TSESTree.ForOfStatement, {
67
+ type: NodeType;
68
+ }> | Extract<TSESTree.ForStatement, {
69
+ type: NodeType;
70
+ }> | Extract<TSESTree.FunctionDeclarationWithName, {
71
+ type: NodeType;
72
+ }> | Extract<TSESTree.FunctionDeclarationWithOptionalName, {
73
+ type: NodeType;
74
+ }> | Extract<TSESTree.FunctionExpression, {
75
+ type: NodeType;
76
+ }> | Extract<TSESTree.Identifier, {
77
+ type: NodeType;
78
+ }> | Extract<TSESTree.IfStatement, {
79
+ type: NodeType;
80
+ }> | Extract<TSESTree.ImportAttribute, {
81
+ type: NodeType;
82
+ }> | Extract<TSESTree.ImportDeclaration, {
83
+ type: NodeType;
84
+ }> | Extract<TSESTree.ImportDefaultSpecifier, {
85
+ type: NodeType;
86
+ }> | Extract<TSESTree.ImportExpression, {
87
+ type: NodeType;
88
+ }> | Extract<TSESTree.ImportNamespaceSpecifier, {
89
+ type: NodeType;
90
+ }> | Extract<TSESTree.ImportSpecifier, {
91
+ type: NodeType;
92
+ }> | Extract<TSESTree.JSXAttribute, {
93
+ type: NodeType;
94
+ }> | Extract<TSESTree.JSXClosingElement, {
95
+ type: NodeType;
96
+ }> | Extract<TSESTree.JSXClosingFragment, {
97
+ type: NodeType;
98
+ }> | Extract<TSESTree.JSXElement, {
99
+ type: NodeType;
100
+ }> | Extract<TSESTree.JSXEmptyExpression, {
101
+ type: NodeType;
102
+ }> | Extract<TSESTree.JSXExpressionContainer, {
103
+ type: NodeType;
104
+ }> | Extract<TSESTree.JSXFragment, {
105
+ type: NodeType;
106
+ }> | Extract<TSESTree.JSXIdentifier, {
107
+ type: NodeType;
108
+ }> | Extract<TSESTree.JSXMemberExpression, {
109
+ type: NodeType;
110
+ }> | Extract<TSESTree.JSXNamespacedName, {
111
+ type: NodeType;
112
+ }> | Extract<TSESTree.JSXOpeningElement, {
113
+ type: NodeType;
114
+ }> | Extract<TSESTree.JSXOpeningFragment, {
115
+ type: NodeType;
116
+ }> | Extract<TSESTree.JSXSpreadAttribute, {
117
+ type: NodeType;
118
+ }> | Extract<TSESTree.JSXSpreadChild, {
119
+ type: NodeType;
120
+ }> | Extract<TSESTree.JSXText, {
121
+ type: NodeType;
122
+ }> | Extract<TSESTree.LabeledStatement, {
123
+ type: NodeType;
124
+ }> | Extract<TSESTree.BigIntLiteral, {
125
+ type: NodeType;
126
+ }> | Extract<TSESTree.BooleanLiteral, {
127
+ type: NodeType;
128
+ }> | Extract<TSESTree.NullLiteral, {
129
+ type: NodeType;
130
+ }> | Extract<TSESTree.NumberLiteral, {
131
+ type: NodeType;
132
+ }> | Extract<TSESTree.RegExpLiteral, {
133
+ type: NodeType;
134
+ }> | Extract<TSESTree.StringLiteral, {
135
+ type: NodeType;
136
+ }> | Extract<TSESTree.LogicalExpression, {
137
+ type: NodeType;
138
+ }> | Extract<TSESTree.MemberExpressionComputedName, {
139
+ type: NodeType;
140
+ }> | Extract<TSESTree.MemberExpressionNonComputedName, {
141
+ type: NodeType;
142
+ }> | Extract<TSESTree.MetaProperty, {
143
+ type: NodeType;
144
+ }> | Extract<TSESTree.MethodDefinitionComputedName, {
145
+ type: NodeType;
146
+ }> | Extract<TSESTree.MethodDefinitionNonComputedName, {
147
+ type: NodeType;
148
+ }> | Extract<TSESTree.NewExpression, {
149
+ type: NodeType;
150
+ }> | Extract<TSESTree.ObjectExpression, {
151
+ type: NodeType;
152
+ }> | Extract<TSESTree.ObjectPattern, {
153
+ type: NodeType;
154
+ }> | Extract<TSESTree.PrivateIdentifier, {
155
+ type: NodeType;
156
+ }> | Extract<TSESTree.Program, {
157
+ type: NodeType;
158
+ }> | Extract<TSESTree.PropertyComputedName, {
159
+ type: NodeType;
160
+ }> | Extract<TSESTree.PropertyNonComputedName, {
161
+ type: NodeType;
162
+ }> | Extract<TSESTree.PropertyDefinitionComputedName, {
163
+ type: NodeType;
164
+ }> | Extract<TSESTree.PropertyDefinitionNonComputedName, {
165
+ type: NodeType;
166
+ }> | Extract<TSESTree.RestElement, {
167
+ type: NodeType;
168
+ }> | Extract<TSESTree.ReturnStatement, {
169
+ type: NodeType;
170
+ }> | Extract<TSESTree.SequenceExpression, {
171
+ type: NodeType;
172
+ }> | Extract<TSESTree.SpreadElement, {
173
+ type: NodeType;
174
+ }> | Extract<TSESTree.StaticBlock, {
175
+ type: NodeType;
176
+ }> | Extract<TSESTree.Super, {
177
+ type: NodeType;
178
+ }> | Extract<TSESTree.SwitchCase, {
179
+ type: NodeType;
180
+ }> | Extract<TSESTree.SwitchStatement, {
181
+ type: NodeType;
182
+ }> | Extract<TSESTree.TaggedTemplateExpression, {
183
+ type: NodeType;
184
+ }> | Extract<TSESTree.TemplateElement, {
185
+ type: NodeType;
186
+ }> | Extract<TSESTree.TemplateLiteral, {
187
+ type: NodeType;
188
+ }> | Extract<TSESTree.ThisExpression, {
189
+ type: NodeType;
190
+ }> | Extract<TSESTree.ThrowStatement, {
191
+ type: NodeType;
192
+ }> | Extract<TSESTree.TryStatement, {
193
+ type: NodeType;
194
+ }> | Extract<TSESTree.TSAbstractAccessorPropertyComputedName, {
195
+ type: NodeType;
196
+ }> | Extract<TSESTree.TSAbstractAccessorPropertyNonComputedName, {
197
+ type: NodeType;
198
+ }> | Extract<TSESTree.TSAbstractKeyword, {
199
+ type: NodeType;
200
+ }> | Extract<TSESTree.TSAbstractMethodDefinitionComputedName, {
201
+ type: NodeType;
202
+ }> | Extract<TSESTree.TSAbstractMethodDefinitionNonComputedName, {
203
+ type: NodeType;
204
+ }> | Extract<TSESTree.TSAbstractPropertyDefinitionComputedName, {
205
+ type: NodeType;
206
+ }> | Extract<TSESTree.TSAbstractPropertyDefinitionNonComputedName, {
207
+ type: NodeType;
208
+ }> | Extract<TSESTree.TSAnyKeyword, {
209
+ type: NodeType;
210
+ }> | Extract<TSESTree.TSArrayType, {
211
+ type: NodeType;
212
+ }> | Extract<TSESTree.TSAsExpression, {
213
+ type: NodeType;
214
+ }> | Extract<TSESTree.TSAsyncKeyword, {
215
+ type: NodeType;
216
+ }> | Extract<TSESTree.TSBigIntKeyword, {
217
+ type: NodeType;
218
+ }> | Extract<TSESTree.TSBooleanKeyword, {
219
+ type: NodeType;
220
+ }> | Extract<TSESTree.TSCallSignatureDeclaration, {
221
+ type: NodeType;
222
+ }> | Extract<TSESTree.TSClassImplements, {
223
+ type: NodeType;
224
+ }> | Extract<TSESTree.TSConditionalType, {
225
+ type: NodeType;
226
+ }> | Extract<TSESTree.TSConstructorType, {
227
+ type: NodeType;
228
+ }> | Extract<TSESTree.TSConstructSignatureDeclaration, {
229
+ type: NodeType;
230
+ }> | Extract<TSESTree.TSDeclareFunction, {
231
+ type: NodeType;
232
+ }> | Extract<TSESTree.TSDeclareKeyword, {
233
+ type: NodeType;
234
+ }> | Extract<TSESTree.TSEmptyBodyFunctionExpression, {
235
+ type: NodeType;
236
+ }> | Extract<TSESTree.TSEnumDeclaration, {
237
+ type: NodeType;
238
+ }> | Extract<TSESTree.TSEnumMemberComputedName, {
239
+ type: NodeType;
240
+ }> | Extract<TSESTree.TSEnumMemberNonComputedName, {
241
+ type: NodeType;
242
+ }> | Extract<TSESTree.TSExportAssignment, {
243
+ type: NodeType;
244
+ }> | Extract<TSESTree.TSExportKeyword, {
245
+ type: NodeType;
246
+ }> | Extract<TSESTree.TSExternalModuleReference, {
247
+ type: NodeType;
248
+ }> | Extract<TSESTree.TSFunctionType, {
249
+ type: NodeType;
250
+ }> | Extract<TSESTree.TSImportEqualsDeclaration, {
251
+ type: NodeType;
252
+ }> | Extract<TSESTree.TSImportType, {
253
+ type: NodeType;
254
+ }> | Extract<TSESTree.TSIndexedAccessType, {
255
+ type: NodeType;
256
+ }> | Extract<TSESTree.TSIndexSignature, {
257
+ type: NodeType;
258
+ }> | Extract<TSESTree.TSInferType, {
259
+ type: NodeType;
260
+ }> | Extract<TSESTree.TSInstantiationExpression, {
261
+ type: NodeType;
262
+ }> | Extract<TSESTree.TSInterfaceBody, {
263
+ type: NodeType;
264
+ }> | Extract<TSESTree.TSInterfaceDeclaration, {
265
+ type: NodeType;
266
+ }> | Extract<TSESTree.TSInterfaceHeritage, {
267
+ type: NodeType;
268
+ }> | Extract<TSESTree.TSIntersectionType, {
269
+ type: NodeType;
270
+ }> | Extract<TSESTree.TSIntrinsicKeyword, {
271
+ type: NodeType;
272
+ }> | Extract<TSESTree.TSLiteralType, {
273
+ type: NodeType;
274
+ }> | Extract<TSESTree.TSMappedType, {
275
+ type: NodeType;
276
+ }> | Extract<TSESTree.TSMethodSignatureComputedName, {
277
+ type: NodeType;
278
+ }> | Extract<TSESTree.TSMethodSignatureNonComputedName, {
279
+ type: NodeType;
280
+ }> | Extract<TSESTree.TSModuleBlock, {
281
+ type: NodeType;
282
+ }> | Extract<TSESTree.TSModuleDeclarationGlobal, {
283
+ type: NodeType;
284
+ }> | Extract<TSESTree.TSModuleDeclarationModuleWithIdentifierId, {
285
+ type: NodeType;
286
+ }> | Extract<TSESTree.TSModuleDeclarationModuleWithStringIdDeclared, {
287
+ type: NodeType;
288
+ }> | Extract<TSESTree.TSModuleDeclarationModuleWithStringIdNotDeclared, {
289
+ type: NodeType;
290
+ }> | Extract<TSESTree.TSModuleDeclarationNamespace, {
291
+ type: NodeType;
292
+ }> | Extract<TSESTree.TSNamedTupleMember, {
293
+ type: NodeType;
294
+ }> | Extract<TSESTree.TSNamespaceExportDeclaration, {
295
+ type: NodeType;
296
+ }> | Extract<TSESTree.TSNeverKeyword, {
297
+ type: NodeType;
298
+ }> | Extract<TSESTree.TSNonNullExpression, {
299
+ type: NodeType;
300
+ }> | Extract<TSESTree.TSNullKeyword, {
301
+ type: NodeType;
302
+ }> | Extract<TSESTree.TSNumberKeyword, {
303
+ type: NodeType;
304
+ }> | Extract<TSESTree.TSObjectKeyword, {
305
+ type: NodeType;
306
+ }> | Extract<TSESTree.TSOptionalType, {
307
+ type: NodeType;
308
+ }> | Extract<TSESTree.TSParameterProperty, {
309
+ type: NodeType;
310
+ }> | Extract<TSESTree.TSPrivateKeyword, {
311
+ type: NodeType;
312
+ }> | Extract<TSESTree.TSPropertySignatureComputedName, {
313
+ type: NodeType;
314
+ }> | Extract<TSESTree.TSPropertySignatureNonComputedName, {
315
+ type: NodeType;
316
+ }> | Extract<TSESTree.TSProtectedKeyword, {
317
+ type: NodeType;
318
+ }> | Extract<TSESTree.TSPublicKeyword, {
319
+ type: NodeType;
320
+ }> | Extract<TSESTree.TSQualifiedName, {
321
+ type: NodeType;
322
+ }> | Extract<TSESTree.TSReadonlyKeyword, {
323
+ type: NodeType;
324
+ }> | Extract<TSESTree.TSRestType, {
325
+ type: NodeType;
326
+ }> | Extract<TSESTree.TSSatisfiesExpression, {
327
+ type: NodeType;
328
+ }> | Extract<TSESTree.TSStaticKeyword, {
329
+ type: NodeType;
330
+ }> | Extract<TSESTree.TSStringKeyword, {
331
+ type: NodeType;
332
+ }> | Extract<TSESTree.TSSymbolKeyword, {
333
+ type: NodeType;
334
+ }> | Extract<TSESTree.TSTemplateLiteralType, {
335
+ type: NodeType;
336
+ }> | Extract<TSESTree.TSThisType, {
337
+ type: NodeType;
338
+ }> | Extract<TSESTree.TSTupleType, {
339
+ type: NodeType;
340
+ }> | Extract<TSESTree.TSTypeAliasDeclaration, {
341
+ type: NodeType;
342
+ }> | Extract<TSESTree.TSTypeAnnotation, {
343
+ type: NodeType;
344
+ }> | Extract<TSESTree.TSTypeAssertion, {
345
+ type: NodeType;
346
+ }> | Extract<TSESTree.TSTypeLiteral, {
347
+ type: NodeType;
348
+ }> | Extract<TSESTree.TSTypeOperator, {
349
+ type: NodeType;
350
+ }> | Extract<TSESTree.TSTypeParameter, {
351
+ type: NodeType;
352
+ }> | Extract<TSESTree.TSTypeParameterDeclaration, {
353
+ type: NodeType;
354
+ }> | Extract<TSESTree.TSTypeParameterInstantiation, {
355
+ type: NodeType;
356
+ }> | Extract<TSESTree.TSTypePredicate, {
357
+ type: NodeType;
358
+ }> | Extract<TSESTree.TSTypeQuery, {
359
+ type: NodeType;
360
+ }> | Extract<TSESTree.TSTypeReference, {
361
+ type: NodeType;
362
+ }> | Extract<TSESTree.TSUndefinedKeyword, {
363
+ type: NodeType;
364
+ }> | Extract<TSESTree.TSUnionType, {
365
+ type: NodeType;
366
+ }> | Extract<TSESTree.TSUnknownKeyword, {
367
+ type: NodeType;
368
+ }> | Extract<TSESTree.TSVoidKeyword, {
369
+ type: NodeType;
370
+ }> | Extract<TSESTree.UnaryExpression, {
371
+ type: NodeType;
372
+ }> | Extract<TSESTree.UpdateExpression, {
373
+ type: NodeType;
374
+ }> | Extract<TSESTree.VariableDeclaration, {
375
+ type: NodeType;
376
+ }> | Extract<TSESTree.VariableDeclarator, {
377
+ type: NodeType;
378
+ }> | Extract<TSESTree.WhileStatement, {
379
+ type: NodeType;
380
+ }> | Extract<TSESTree.WithStatement, {
381
+ type: NodeType;
382
+ }> | Extract<TSESTree.YieldExpression, {
383
+ type: NodeType;
384
+ }>;
385
+ export declare const isNodeOfTypes: <NodeTypes extends readonly AST_NODE_TYPES[]>(nodeTypes: NodeTypes) => (node: TSESTree.Node | null | undefined) => node is Extract<TSESTree.AccessorPropertyComputedName, {
386
+ type: NodeTypes[number];
387
+ }> | Extract<TSESTree.AccessorPropertyNonComputedName, {
388
+ type: NodeTypes[number];
389
+ }> | Extract<TSESTree.ArrayExpression, {
390
+ type: NodeTypes[number];
391
+ }> | Extract<TSESTree.ArrayPattern, {
392
+ type: NodeTypes[number];
393
+ }> | Extract<TSESTree.ArrowFunctionExpression, {
394
+ type: NodeTypes[number];
395
+ }> | Extract<TSESTree.AssignmentExpression, {
396
+ type: NodeTypes[number];
397
+ }> | Extract<TSESTree.AssignmentPattern, {
398
+ type: NodeTypes[number];
399
+ }> | Extract<TSESTree.AwaitExpression, {
400
+ type: NodeTypes[number];
401
+ }> | Extract<TSESTree.BinaryExpression, {
402
+ type: NodeTypes[number];
403
+ }> | Extract<TSESTree.BlockStatement, {
404
+ type: NodeTypes[number];
405
+ }> | Extract<TSESTree.BreakStatement, {
406
+ type: NodeTypes[number];
407
+ }> | Extract<TSESTree.CallExpression, {
408
+ type: NodeTypes[number];
409
+ }> | Extract<TSESTree.CatchClause, {
410
+ type: NodeTypes[number];
411
+ }> | Extract<TSESTree.ChainExpression, {
412
+ type: NodeTypes[number];
413
+ }> | Extract<TSESTree.ClassBody, {
414
+ type: NodeTypes[number];
415
+ }> | Extract<TSESTree.ClassDeclarationWithName, {
416
+ type: NodeTypes[number];
417
+ }> | Extract<TSESTree.ClassDeclarationWithOptionalName, {
418
+ type: NodeTypes[number];
419
+ }> | Extract<TSESTree.ClassExpression, {
420
+ type: NodeTypes[number];
421
+ }> | Extract<TSESTree.ConditionalExpression, {
422
+ type: NodeTypes[number];
423
+ }> | Extract<TSESTree.ContinueStatement, {
424
+ type: NodeTypes[number];
425
+ }> | Extract<TSESTree.DebuggerStatement, {
426
+ type: NodeTypes[number];
427
+ }> | Extract<TSESTree.Decorator, {
428
+ type: NodeTypes[number];
429
+ }> | Extract<TSESTree.DoWhileStatement, {
430
+ type: NodeTypes[number];
431
+ }> | Extract<TSESTree.EmptyStatement, {
432
+ type: NodeTypes[number];
433
+ }> | Extract<TSESTree.ExportAllDeclaration, {
434
+ type: NodeTypes[number];
435
+ }> | Extract<TSESTree.ExportDefaultDeclaration, {
436
+ type: NodeTypes[number];
437
+ }> | Extract<TSESTree.ExportNamedDeclarationWithoutSourceWithMultiple, {
438
+ type: NodeTypes[number];
439
+ }> | Extract<TSESTree.ExportNamedDeclarationWithoutSourceWithSingle, {
440
+ type: NodeTypes[number];
441
+ }> | Extract<TSESTree.ExportNamedDeclarationWithSource, {
442
+ type: NodeTypes[number];
443
+ }> | Extract<TSESTree.ExportSpecifier, {
444
+ type: NodeTypes[number];
445
+ }> | Extract<TSESTree.ExpressionStatement, {
446
+ type: NodeTypes[number];
447
+ }> | Extract<TSESTree.ForInStatement, {
448
+ type: NodeTypes[number];
449
+ }> | Extract<TSESTree.ForOfStatement, {
450
+ type: NodeTypes[number];
451
+ }> | Extract<TSESTree.ForStatement, {
452
+ type: NodeTypes[number];
453
+ }> | Extract<TSESTree.FunctionDeclarationWithName, {
454
+ type: NodeTypes[number];
455
+ }> | Extract<TSESTree.FunctionDeclarationWithOptionalName, {
456
+ type: NodeTypes[number];
457
+ }> | Extract<TSESTree.FunctionExpression, {
458
+ type: NodeTypes[number];
459
+ }> | Extract<TSESTree.Identifier, {
460
+ type: NodeTypes[number];
461
+ }> | Extract<TSESTree.IfStatement, {
462
+ type: NodeTypes[number];
463
+ }> | Extract<TSESTree.ImportAttribute, {
464
+ type: NodeTypes[number];
465
+ }> | Extract<TSESTree.ImportDeclaration, {
466
+ type: NodeTypes[number];
467
+ }> | Extract<TSESTree.ImportDefaultSpecifier, {
468
+ type: NodeTypes[number];
469
+ }> | Extract<TSESTree.ImportExpression, {
470
+ type: NodeTypes[number];
471
+ }> | Extract<TSESTree.ImportNamespaceSpecifier, {
472
+ type: NodeTypes[number];
473
+ }> | Extract<TSESTree.ImportSpecifier, {
474
+ type: NodeTypes[number];
475
+ }> | Extract<TSESTree.JSXAttribute, {
476
+ type: NodeTypes[number];
477
+ }> | Extract<TSESTree.JSXClosingElement, {
478
+ type: NodeTypes[number];
479
+ }> | Extract<TSESTree.JSXClosingFragment, {
480
+ type: NodeTypes[number];
481
+ }> | Extract<TSESTree.JSXElement, {
482
+ type: NodeTypes[number];
483
+ }> | Extract<TSESTree.JSXEmptyExpression, {
484
+ type: NodeTypes[number];
485
+ }> | Extract<TSESTree.JSXExpressionContainer, {
486
+ type: NodeTypes[number];
487
+ }> | Extract<TSESTree.JSXFragment, {
488
+ type: NodeTypes[number];
489
+ }> | Extract<TSESTree.JSXIdentifier, {
490
+ type: NodeTypes[number];
491
+ }> | Extract<TSESTree.JSXMemberExpression, {
492
+ type: NodeTypes[number];
493
+ }> | Extract<TSESTree.JSXNamespacedName, {
494
+ type: NodeTypes[number];
495
+ }> | Extract<TSESTree.JSXOpeningElement, {
496
+ type: NodeTypes[number];
497
+ }> | Extract<TSESTree.JSXOpeningFragment, {
498
+ type: NodeTypes[number];
499
+ }> | Extract<TSESTree.JSXSpreadAttribute, {
500
+ type: NodeTypes[number];
501
+ }> | Extract<TSESTree.JSXSpreadChild, {
502
+ type: NodeTypes[number];
503
+ }> | Extract<TSESTree.JSXText, {
504
+ type: NodeTypes[number];
505
+ }> | Extract<TSESTree.LabeledStatement, {
506
+ type: NodeTypes[number];
507
+ }> | Extract<TSESTree.BigIntLiteral, {
508
+ type: NodeTypes[number];
509
+ }> | Extract<TSESTree.BooleanLiteral, {
510
+ type: NodeTypes[number];
511
+ }> | Extract<TSESTree.NullLiteral, {
512
+ type: NodeTypes[number];
513
+ }> | Extract<TSESTree.NumberLiteral, {
514
+ type: NodeTypes[number];
515
+ }> | Extract<TSESTree.RegExpLiteral, {
516
+ type: NodeTypes[number];
517
+ }> | Extract<TSESTree.StringLiteral, {
518
+ type: NodeTypes[number];
519
+ }> | Extract<TSESTree.LogicalExpression, {
520
+ type: NodeTypes[number];
521
+ }> | Extract<TSESTree.MemberExpressionComputedName, {
522
+ type: NodeTypes[number];
523
+ }> | Extract<TSESTree.MemberExpressionNonComputedName, {
524
+ type: NodeTypes[number];
525
+ }> | Extract<TSESTree.MetaProperty, {
526
+ type: NodeTypes[number];
527
+ }> | Extract<TSESTree.MethodDefinitionComputedName, {
528
+ type: NodeTypes[number];
529
+ }> | Extract<TSESTree.MethodDefinitionNonComputedName, {
530
+ type: NodeTypes[number];
531
+ }> | Extract<TSESTree.NewExpression, {
532
+ type: NodeTypes[number];
533
+ }> | Extract<TSESTree.ObjectExpression, {
534
+ type: NodeTypes[number];
535
+ }> | Extract<TSESTree.ObjectPattern, {
536
+ type: NodeTypes[number];
537
+ }> | Extract<TSESTree.PrivateIdentifier, {
538
+ type: NodeTypes[number];
539
+ }> | Extract<TSESTree.Program, {
540
+ type: NodeTypes[number];
541
+ }> | Extract<TSESTree.PropertyComputedName, {
542
+ type: NodeTypes[number];
543
+ }> | Extract<TSESTree.PropertyNonComputedName, {
544
+ type: NodeTypes[number];
545
+ }> | Extract<TSESTree.PropertyDefinitionComputedName, {
546
+ type: NodeTypes[number];
547
+ }> | Extract<TSESTree.PropertyDefinitionNonComputedName, {
548
+ type: NodeTypes[number];
549
+ }> | Extract<TSESTree.RestElement, {
550
+ type: NodeTypes[number];
551
+ }> | Extract<TSESTree.ReturnStatement, {
552
+ type: NodeTypes[number];
553
+ }> | Extract<TSESTree.SequenceExpression, {
554
+ type: NodeTypes[number];
555
+ }> | Extract<TSESTree.SpreadElement, {
556
+ type: NodeTypes[number];
557
+ }> | Extract<TSESTree.StaticBlock, {
558
+ type: NodeTypes[number];
559
+ }> | Extract<TSESTree.Super, {
560
+ type: NodeTypes[number];
561
+ }> | Extract<TSESTree.SwitchCase, {
562
+ type: NodeTypes[number];
563
+ }> | Extract<TSESTree.SwitchStatement, {
564
+ type: NodeTypes[number];
565
+ }> | Extract<TSESTree.TaggedTemplateExpression, {
566
+ type: NodeTypes[number];
567
+ }> | Extract<TSESTree.TemplateElement, {
568
+ type: NodeTypes[number];
569
+ }> | Extract<TSESTree.TemplateLiteral, {
570
+ type: NodeTypes[number];
571
+ }> | Extract<TSESTree.ThisExpression, {
572
+ type: NodeTypes[number];
573
+ }> | Extract<TSESTree.ThrowStatement, {
574
+ type: NodeTypes[number];
575
+ }> | Extract<TSESTree.TryStatement, {
576
+ type: NodeTypes[number];
577
+ }> | Extract<TSESTree.TSAbstractAccessorPropertyComputedName, {
578
+ type: NodeTypes[number];
579
+ }> | Extract<TSESTree.TSAbstractAccessorPropertyNonComputedName, {
580
+ type: NodeTypes[number];
581
+ }> | Extract<TSESTree.TSAbstractKeyword, {
582
+ type: NodeTypes[number];
583
+ }> | Extract<TSESTree.TSAbstractMethodDefinitionComputedName, {
584
+ type: NodeTypes[number];
585
+ }> | Extract<TSESTree.TSAbstractMethodDefinitionNonComputedName, {
586
+ type: NodeTypes[number];
587
+ }> | Extract<TSESTree.TSAbstractPropertyDefinitionComputedName, {
588
+ type: NodeTypes[number];
589
+ }> | Extract<TSESTree.TSAbstractPropertyDefinitionNonComputedName, {
590
+ type: NodeTypes[number];
591
+ }> | Extract<TSESTree.TSAnyKeyword, {
592
+ type: NodeTypes[number];
593
+ }> | Extract<TSESTree.TSArrayType, {
594
+ type: NodeTypes[number];
595
+ }> | Extract<TSESTree.TSAsExpression, {
596
+ type: NodeTypes[number];
597
+ }> | Extract<TSESTree.TSAsyncKeyword, {
598
+ type: NodeTypes[number];
599
+ }> | Extract<TSESTree.TSBigIntKeyword, {
600
+ type: NodeTypes[number];
601
+ }> | Extract<TSESTree.TSBooleanKeyword, {
602
+ type: NodeTypes[number];
603
+ }> | Extract<TSESTree.TSCallSignatureDeclaration, {
604
+ type: NodeTypes[number];
605
+ }> | Extract<TSESTree.TSClassImplements, {
606
+ type: NodeTypes[number];
607
+ }> | Extract<TSESTree.TSConditionalType, {
608
+ type: NodeTypes[number];
609
+ }> | Extract<TSESTree.TSConstructorType, {
610
+ type: NodeTypes[number];
611
+ }> | Extract<TSESTree.TSConstructSignatureDeclaration, {
612
+ type: NodeTypes[number];
613
+ }> | Extract<TSESTree.TSDeclareFunction, {
614
+ type: NodeTypes[number];
615
+ }> | Extract<TSESTree.TSDeclareKeyword, {
616
+ type: NodeTypes[number];
617
+ }> | Extract<TSESTree.TSEmptyBodyFunctionExpression, {
618
+ type: NodeTypes[number];
619
+ }> | Extract<TSESTree.TSEnumDeclaration, {
620
+ type: NodeTypes[number];
621
+ }> | Extract<TSESTree.TSEnumMemberComputedName, {
622
+ type: NodeTypes[number];
623
+ }> | Extract<TSESTree.TSEnumMemberNonComputedName, {
624
+ type: NodeTypes[number];
625
+ }> | Extract<TSESTree.TSExportAssignment, {
626
+ type: NodeTypes[number];
627
+ }> | Extract<TSESTree.TSExportKeyword, {
628
+ type: NodeTypes[number];
629
+ }> | Extract<TSESTree.TSExternalModuleReference, {
630
+ type: NodeTypes[number];
631
+ }> | Extract<TSESTree.TSFunctionType, {
632
+ type: NodeTypes[number];
633
+ }> | Extract<TSESTree.TSImportEqualsDeclaration, {
634
+ type: NodeTypes[number];
635
+ }> | Extract<TSESTree.TSImportType, {
636
+ type: NodeTypes[number];
637
+ }> | Extract<TSESTree.TSIndexedAccessType, {
638
+ type: NodeTypes[number];
639
+ }> | Extract<TSESTree.TSIndexSignature, {
640
+ type: NodeTypes[number];
641
+ }> | Extract<TSESTree.TSInferType, {
642
+ type: NodeTypes[number];
643
+ }> | Extract<TSESTree.TSInstantiationExpression, {
644
+ type: NodeTypes[number];
645
+ }> | Extract<TSESTree.TSInterfaceBody, {
646
+ type: NodeTypes[number];
647
+ }> | Extract<TSESTree.TSInterfaceDeclaration, {
648
+ type: NodeTypes[number];
649
+ }> | Extract<TSESTree.TSInterfaceHeritage, {
650
+ type: NodeTypes[number];
651
+ }> | Extract<TSESTree.TSIntersectionType, {
652
+ type: NodeTypes[number];
653
+ }> | Extract<TSESTree.TSIntrinsicKeyword, {
654
+ type: NodeTypes[number];
655
+ }> | Extract<TSESTree.TSLiteralType, {
656
+ type: NodeTypes[number];
657
+ }> | Extract<TSESTree.TSMappedType, {
658
+ type: NodeTypes[number];
659
+ }> | Extract<TSESTree.TSMethodSignatureComputedName, {
660
+ type: NodeTypes[number];
661
+ }> | Extract<TSESTree.TSMethodSignatureNonComputedName, {
662
+ type: NodeTypes[number];
663
+ }> | Extract<TSESTree.TSModuleBlock, {
664
+ type: NodeTypes[number];
665
+ }> | Extract<TSESTree.TSModuleDeclarationGlobal, {
666
+ type: NodeTypes[number];
667
+ }> | Extract<TSESTree.TSModuleDeclarationModuleWithIdentifierId, {
668
+ type: NodeTypes[number];
669
+ }> | Extract<TSESTree.TSModuleDeclarationModuleWithStringIdDeclared, {
670
+ type: NodeTypes[number];
671
+ }> | Extract<TSESTree.TSModuleDeclarationModuleWithStringIdNotDeclared, {
672
+ type: NodeTypes[number];
673
+ }> | Extract<TSESTree.TSModuleDeclarationNamespace, {
674
+ type: NodeTypes[number];
675
+ }> | Extract<TSESTree.TSNamedTupleMember, {
676
+ type: NodeTypes[number];
677
+ }> | Extract<TSESTree.TSNamespaceExportDeclaration, {
678
+ type: NodeTypes[number];
679
+ }> | Extract<TSESTree.TSNeverKeyword, {
680
+ type: NodeTypes[number];
681
+ }> | Extract<TSESTree.TSNonNullExpression, {
682
+ type: NodeTypes[number];
683
+ }> | Extract<TSESTree.TSNullKeyword, {
684
+ type: NodeTypes[number];
685
+ }> | Extract<TSESTree.TSNumberKeyword, {
686
+ type: NodeTypes[number];
687
+ }> | Extract<TSESTree.TSObjectKeyword, {
688
+ type: NodeTypes[number];
689
+ }> | Extract<TSESTree.TSOptionalType, {
690
+ type: NodeTypes[number];
691
+ }> | Extract<TSESTree.TSParameterProperty, {
692
+ type: NodeTypes[number];
693
+ }> | Extract<TSESTree.TSPrivateKeyword, {
694
+ type: NodeTypes[number];
695
+ }> | Extract<TSESTree.TSPropertySignatureComputedName, {
696
+ type: NodeTypes[number];
697
+ }> | Extract<TSESTree.TSPropertySignatureNonComputedName, {
698
+ type: NodeTypes[number];
699
+ }> | Extract<TSESTree.TSProtectedKeyword, {
700
+ type: NodeTypes[number];
701
+ }> | Extract<TSESTree.TSPublicKeyword, {
702
+ type: NodeTypes[number];
703
+ }> | Extract<TSESTree.TSQualifiedName, {
704
+ type: NodeTypes[number];
705
+ }> | Extract<TSESTree.TSReadonlyKeyword, {
706
+ type: NodeTypes[number];
707
+ }> | Extract<TSESTree.TSRestType, {
708
+ type: NodeTypes[number];
709
+ }> | Extract<TSESTree.TSSatisfiesExpression, {
710
+ type: NodeTypes[number];
711
+ }> | Extract<TSESTree.TSStaticKeyword, {
712
+ type: NodeTypes[number];
713
+ }> | Extract<TSESTree.TSStringKeyword, {
714
+ type: NodeTypes[number];
715
+ }> | Extract<TSESTree.TSSymbolKeyword, {
716
+ type: NodeTypes[number];
717
+ }> | Extract<TSESTree.TSTemplateLiteralType, {
718
+ type: NodeTypes[number];
719
+ }> | Extract<TSESTree.TSThisType, {
720
+ type: NodeTypes[number];
721
+ }> | Extract<TSESTree.TSTupleType, {
722
+ type: NodeTypes[number];
723
+ }> | Extract<TSESTree.TSTypeAliasDeclaration, {
724
+ type: NodeTypes[number];
725
+ }> | Extract<TSESTree.TSTypeAnnotation, {
726
+ type: NodeTypes[number];
727
+ }> | Extract<TSESTree.TSTypeAssertion, {
728
+ type: NodeTypes[number];
729
+ }> | Extract<TSESTree.TSTypeLiteral, {
730
+ type: NodeTypes[number];
731
+ }> | Extract<TSESTree.TSTypeOperator, {
732
+ type: NodeTypes[number];
733
+ }> | Extract<TSESTree.TSTypeParameter, {
734
+ type: NodeTypes[number];
735
+ }> | Extract<TSESTree.TSTypeParameterDeclaration, {
736
+ type: NodeTypes[number];
737
+ }> | Extract<TSESTree.TSTypeParameterInstantiation, {
738
+ type: NodeTypes[number];
739
+ }> | Extract<TSESTree.TSTypePredicate, {
740
+ type: NodeTypes[number];
741
+ }> | Extract<TSESTree.TSTypeQuery, {
742
+ type: NodeTypes[number];
743
+ }> | Extract<TSESTree.TSTypeReference, {
744
+ type: NodeTypes[number];
745
+ }> | Extract<TSESTree.TSUndefinedKeyword, {
746
+ type: NodeTypes[number];
747
+ }> | Extract<TSESTree.TSUnionType, {
748
+ type: NodeTypes[number];
749
+ }> | Extract<TSESTree.TSUnknownKeyword, {
750
+ type: NodeTypes[number];
751
+ }> | Extract<TSESTree.TSVoidKeyword, {
752
+ type: NodeTypes[number];
753
+ }> | Extract<TSESTree.UnaryExpression, {
754
+ type: NodeTypes[number];
755
+ }> | Extract<TSESTree.UpdateExpression, {
756
+ type: NodeTypes[number];
757
+ }> | Extract<TSESTree.VariableDeclaration, {
758
+ type: NodeTypes[number];
759
+ }> | Extract<TSESTree.VariableDeclarator, {
760
+ type: NodeTypes[number];
761
+ }> | Extract<TSESTree.WhileStatement, {
762
+ type: NodeTypes[number];
763
+ }> | Extract<TSESTree.WithStatement, {
764
+ type: NodeTypes[number];
765
+ }> | Extract<TSESTree.YieldExpression, {
766
+ type: NodeTypes[number];
767
+ }>;
768
+ export declare const isNodeOfTypeWithConditions: <NodeType extends AST_NODE_TYPES, ExtractedNode extends Extract<TSESTree.AccessorPropertyComputedName, {
769
+ type: NodeType;
770
+ }> | Extract<TSESTree.AccessorPropertyNonComputedName, {
771
+ type: NodeType;
772
+ }> | Extract<TSESTree.ArrayExpression, {
773
+ type: NodeType;
774
+ }> | Extract<TSESTree.ArrayPattern, {
775
+ type: NodeType;
776
+ }> | Extract<TSESTree.ArrowFunctionExpression, {
777
+ type: NodeType;
778
+ }> | Extract<TSESTree.AssignmentExpression, {
779
+ type: NodeType;
780
+ }> | Extract<TSESTree.AssignmentPattern, {
781
+ type: NodeType;
782
+ }> | Extract<TSESTree.AwaitExpression, {
783
+ type: NodeType;
784
+ }> | Extract<TSESTree.BinaryExpression, {
785
+ type: NodeType;
786
+ }> | Extract<TSESTree.BlockStatement, {
787
+ type: NodeType;
788
+ }> | Extract<TSESTree.BreakStatement, {
789
+ type: NodeType;
790
+ }> | Extract<TSESTree.CallExpression, {
791
+ type: NodeType;
792
+ }> | Extract<TSESTree.CatchClause, {
793
+ type: NodeType;
794
+ }> | Extract<TSESTree.ChainExpression, {
795
+ type: NodeType;
796
+ }> | Extract<TSESTree.ClassBody, {
797
+ type: NodeType;
798
+ }> | Extract<TSESTree.ClassDeclarationWithName, {
799
+ type: NodeType;
800
+ }> | Extract<TSESTree.ClassDeclarationWithOptionalName, {
801
+ type: NodeType;
802
+ }> | Extract<TSESTree.ClassExpression, {
803
+ type: NodeType;
804
+ }> | Extract<TSESTree.ConditionalExpression, {
805
+ type: NodeType;
806
+ }> | Extract<TSESTree.ContinueStatement, {
807
+ type: NodeType;
808
+ }> | Extract<TSESTree.DebuggerStatement, {
809
+ type: NodeType;
810
+ }> | Extract<TSESTree.Decorator, {
811
+ type: NodeType;
812
+ }> | Extract<TSESTree.DoWhileStatement, {
813
+ type: NodeType;
814
+ }> | Extract<TSESTree.EmptyStatement, {
815
+ type: NodeType;
816
+ }> | Extract<TSESTree.ExportAllDeclaration, {
817
+ type: NodeType;
818
+ }> | Extract<TSESTree.ExportDefaultDeclaration, {
819
+ type: NodeType;
820
+ }> | Extract<TSESTree.ExportNamedDeclarationWithoutSourceWithMultiple, {
821
+ type: NodeType;
822
+ }> | Extract<TSESTree.ExportNamedDeclarationWithoutSourceWithSingle, {
823
+ type: NodeType;
824
+ }> | Extract<TSESTree.ExportNamedDeclarationWithSource, {
825
+ type: NodeType;
826
+ }> | Extract<TSESTree.ExportSpecifier, {
827
+ type: NodeType;
828
+ }> | Extract<TSESTree.ExpressionStatement, {
829
+ type: NodeType;
830
+ }> | Extract<TSESTree.ForInStatement, {
831
+ type: NodeType;
832
+ }> | Extract<TSESTree.ForOfStatement, {
833
+ type: NodeType;
834
+ }> | Extract<TSESTree.ForStatement, {
835
+ type: NodeType;
836
+ }> | Extract<TSESTree.FunctionDeclarationWithName, {
837
+ type: NodeType;
838
+ }> | Extract<TSESTree.FunctionDeclarationWithOptionalName, {
839
+ type: NodeType;
840
+ }> | Extract<TSESTree.FunctionExpression, {
841
+ type: NodeType;
842
+ }> | Extract<TSESTree.Identifier, {
843
+ type: NodeType;
844
+ }> | Extract<TSESTree.IfStatement, {
845
+ type: NodeType;
846
+ }> | Extract<TSESTree.ImportAttribute, {
847
+ type: NodeType;
848
+ }> | Extract<TSESTree.ImportDeclaration, {
849
+ type: NodeType;
850
+ }> | Extract<TSESTree.ImportDefaultSpecifier, {
851
+ type: NodeType;
852
+ }> | Extract<TSESTree.ImportExpression, {
853
+ type: NodeType;
854
+ }> | Extract<TSESTree.ImportNamespaceSpecifier, {
855
+ type: NodeType;
856
+ }> | Extract<TSESTree.ImportSpecifier, {
857
+ type: NodeType;
858
+ }> | Extract<TSESTree.JSXAttribute, {
859
+ type: NodeType;
860
+ }> | Extract<TSESTree.JSXClosingElement, {
861
+ type: NodeType;
862
+ }> | Extract<TSESTree.JSXClosingFragment, {
863
+ type: NodeType;
864
+ }> | Extract<TSESTree.JSXElement, {
865
+ type: NodeType;
866
+ }> | Extract<TSESTree.JSXEmptyExpression, {
867
+ type: NodeType;
868
+ }> | Extract<TSESTree.JSXExpressionContainer, {
869
+ type: NodeType;
870
+ }> | Extract<TSESTree.JSXFragment, {
871
+ type: NodeType;
872
+ }> | Extract<TSESTree.JSXIdentifier, {
873
+ type: NodeType;
874
+ }> | Extract<TSESTree.JSXMemberExpression, {
875
+ type: NodeType;
876
+ }> | Extract<TSESTree.JSXNamespacedName, {
877
+ type: NodeType;
878
+ }> | Extract<TSESTree.JSXOpeningElement, {
879
+ type: NodeType;
880
+ }> | Extract<TSESTree.JSXOpeningFragment, {
881
+ type: NodeType;
882
+ }> | Extract<TSESTree.JSXSpreadAttribute, {
883
+ type: NodeType;
884
+ }> | Extract<TSESTree.JSXSpreadChild, {
885
+ type: NodeType;
886
+ }> | Extract<TSESTree.JSXText, {
887
+ type: NodeType;
888
+ }> | Extract<TSESTree.LabeledStatement, {
889
+ type: NodeType;
890
+ }> | Extract<TSESTree.BigIntLiteral, {
891
+ type: NodeType;
892
+ }> | Extract<TSESTree.BooleanLiteral, {
893
+ type: NodeType;
894
+ }> | Extract<TSESTree.NullLiteral, {
895
+ type: NodeType;
896
+ }> | Extract<TSESTree.NumberLiteral, {
897
+ type: NodeType;
898
+ }> | Extract<TSESTree.RegExpLiteral, {
899
+ type: NodeType;
900
+ }> | Extract<TSESTree.StringLiteral, {
901
+ type: NodeType;
902
+ }> | Extract<TSESTree.LogicalExpression, {
903
+ type: NodeType;
904
+ }> | Extract<TSESTree.MemberExpressionComputedName, {
905
+ type: NodeType;
906
+ }> | Extract<TSESTree.MemberExpressionNonComputedName, {
907
+ type: NodeType;
908
+ }> | Extract<TSESTree.MetaProperty, {
909
+ type: NodeType;
910
+ }> | Extract<TSESTree.MethodDefinitionComputedName, {
911
+ type: NodeType;
912
+ }> | Extract<TSESTree.MethodDefinitionNonComputedName, {
913
+ type: NodeType;
914
+ }> | Extract<TSESTree.NewExpression, {
915
+ type: NodeType;
916
+ }> | Extract<TSESTree.ObjectExpression, {
917
+ type: NodeType;
918
+ }> | Extract<TSESTree.ObjectPattern, {
919
+ type: NodeType;
920
+ }> | Extract<TSESTree.PrivateIdentifier, {
921
+ type: NodeType;
922
+ }> | Extract<TSESTree.Program, {
923
+ type: NodeType;
924
+ }> | Extract<TSESTree.PropertyComputedName, {
925
+ type: NodeType;
926
+ }> | Extract<TSESTree.PropertyNonComputedName, {
927
+ type: NodeType;
928
+ }> | Extract<TSESTree.PropertyDefinitionComputedName, {
929
+ type: NodeType;
930
+ }> | Extract<TSESTree.PropertyDefinitionNonComputedName, {
931
+ type: NodeType;
932
+ }> | Extract<TSESTree.RestElement, {
933
+ type: NodeType;
934
+ }> | Extract<TSESTree.ReturnStatement, {
935
+ type: NodeType;
936
+ }> | Extract<TSESTree.SequenceExpression, {
937
+ type: NodeType;
938
+ }> | Extract<TSESTree.SpreadElement, {
939
+ type: NodeType;
940
+ }> | Extract<TSESTree.StaticBlock, {
941
+ type: NodeType;
942
+ }> | Extract<TSESTree.Super, {
943
+ type: NodeType;
944
+ }> | Extract<TSESTree.SwitchCase, {
945
+ type: NodeType;
946
+ }> | Extract<TSESTree.SwitchStatement, {
947
+ type: NodeType;
948
+ }> | Extract<TSESTree.TaggedTemplateExpression, {
949
+ type: NodeType;
950
+ }> | Extract<TSESTree.TemplateElement, {
951
+ type: NodeType;
952
+ }> | Extract<TSESTree.TemplateLiteral, {
953
+ type: NodeType;
954
+ }> | Extract<TSESTree.ThisExpression, {
955
+ type: NodeType;
956
+ }> | Extract<TSESTree.ThrowStatement, {
957
+ type: NodeType;
958
+ }> | Extract<TSESTree.TryStatement, {
959
+ type: NodeType;
960
+ }> | Extract<TSESTree.TSAbstractAccessorPropertyComputedName, {
961
+ type: NodeType;
962
+ }> | Extract<TSESTree.TSAbstractAccessorPropertyNonComputedName, {
963
+ type: NodeType;
964
+ }> | Extract<TSESTree.TSAbstractKeyword, {
965
+ type: NodeType;
966
+ }> | Extract<TSESTree.TSAbstractMethodDefinitionComputedName, {
967
+ type: NodeType;
968
+ }> | Extract<TSESTree.TSAbstractMethodDefinitionNonComputedName, {
969
+ type: NodeType;
970
+ }> | Extract<TSESTree.TSAbstractPropertyDefinitionComputedName, {
971
+ type: NodeType;
972
+ }> | Extract<TSESTree.TSAbstractPropertyDefinitionNonComputedName, {
973
+ type: NodeType;
974
+ }> | Extract<TSESTree.TSAnyKeyword, {
975
+ type: NodeType;
976
+ }> | Extract<TSESTree.TSArrayType, {
977
+ type: NodeType;
978
+ }> | Extract<TSESTree.TSAsExpression, {
979
+ type: NodeType;
980
+ }> | Extract<TSESTree.TSAsyncKeyword, {
981
+ type: NodeType;
982
+ }> | Extract<TSESTree.TSBigIntKeyword, {
983
+ type: NodeType;
984
+ }> | Extract<TSESTree.TSBooleanKeyword, {
985
+ type: NodeType;
986
+ }> | Extract<TSESTree.TSCallSignatureDeclaration, {
987
+ type: NodeType;
988
+ }> | Extract<TSESTree.TSClassImplements, {
989
+ type: NodeType;
990
+ }> | Extract<TSESTree.TSConditionalType, {
991
+ type: NodeType;
992
+ }> | Extract<TSESTree.TSConstructorType, {
993
+ type: NodeType;
994
+ }> | Extract<TSESTree.TSConstructSignatureDeclaration, {
995
+ type: NodeType;
996
+ }> | Extract<TSESTree.TSDeclareFunction, {
997
+ type: NodeType;
998
+ }> | Extract<TSESTree.TSDeclareKeyword, {
999
+ type: NodeType;
1000
+ }> | Extract<TSESTree.TSEmptyBodyFunctionExpression, {
1001
+ type: NodeType;
1002
+ }> | Extract<TSESTree.TSEnumDeclaration, {
1003
+ type: NodeType;
1004
+ }> | Extract<TSESTree.TSEnumMemberComputedName, {
1005
+ type: NodeType;
1006
+ }> | Extract<TSESTree.TSEnumMemberNonComputedName, {
1007
+ type: NodeType;
1008
+ }> | Extract<TSESTree.TSExportAssignment, {
1009
+ type: NodeType;
1010
+ }> | Extract<TSESTree.TSExportKeyword, {
1011
+ type: NodeType;
1012
+ }> | Extract<TSESTree.TSExternalModuleReference, {
1013
+ type: NodeType;
1014
+ }> | Extract<TSESTree.TSFunctionType, {
1015
+ type: NodeType;
1016
+ }> | Extract<TSESTree.TSImportEqualsDeclaration, {
1017
+ type: NodeType;
1018
+ }> | Extract<TSESTree.TSImportType, {
1019
+ type: NodeType;
1020
+ }> | Extract<TSESTree.TSIndexedAccessType, {
1021
+ type: NodeType;
1022
+ }> | Extract<TSESTree.TSIndexSignature, {
1023
+ type: NodeType;
1024
+ }> | Extract<TSESTree.TSInferType, {
1025
+ type: NodeType;
1026
+ }> | Extract<TSESTree.TSInstantiationExpression, {
1027
+ type: NodeType;
1028
+ }> | Extract<TSESTree.TSInterfaceBody, {
1029
+ type: NodeType;
1030
+ }> | Extract<TSESTree.TSInterfaceDeclaration, {
1031
+ type: NodeType;
1032
+ }> | Extract<TSESTree.TSInterfaceHeritage, {
1033
+ type: NodeType;
1034
+ }> | Extract<TSESTree.TSIntersectionType, {
1035
+ type: NodeType;
1036
+ }> | Extract<TSESTree.TSIntrinsicKeyword, {
1037
+ type: NodeType;
1038
+ }> | Extract<TSESTree.TSLiteralType, {
1039
+ type: NodeType;
1040
+ }> | Extract<TSESTree.TSMappedType, {
1041
+ type: NodeType;
1042
+ }> | Extract<TSESTree.TSMethodSignatureComputedName, {
1043
+ type: NodeType;
1044
+ }> | Extract<TSESTree.TSMethodSignatureNonComputedName, {
1045
+ type: NodeType;
1046
+ }> | Extract<TSESTree.TSModuleBlock, {
1047
+ type: NodeType;
1048
+ }> | Extract<TSESTree.TSModuleDeclarationGlobal, {
1049
+ type: NodeType;
1050
+ }> | Extract<TSESTree.TSModuleDeclarationModuleWithIdentifierId, {
1051
+ type: NodeType;
1052
+ }> | Extract<TSESTree.TSModuleDeclarationModuleWithStringIdDeclared, {
1053
+ type: NodeType;
1054
+ }> | Extract<TSESTree.TSModuleDeclarationModuleWithStringIdNotDeclared, {
1055
+ type: NodeType;
1056
+ }> | Extract<TSESTree.TSModuleDeclarationNamespace, {
1057
+ type: NodeType;
1058
+ }> | Extract<TSESTree.TSNamedTupleMember, {
1059
+ type: NodeType;
1060
+ }> | Extract<TSESTree.TSNamespaceExportDeclaration, {
1061
+ type: NodeType;
1062
+ }> | Extract<TSESTree.TSNeverKeyword, {
1063
+ type: NodeType;
1064
+ }> | Extract<TSESTree.TSNonNullExpression, {
1065
+ type: NodeType;
1066
+ }> | Extract<TSESTree.TSNullKeyword, {
1067
+ type: NodeType;
1068
+ }> | Extract<TSESTree.TSNumberKeyword, {
1069
+ type: NodeType;
1070
+ }> | Extract<TSESTree.TSObjectKeyword, {
1071
+ type: NodeType;
1072
+ }> | Extract<TSESTree.TSOptionalType, {
1073
+ type: NodeType;
1074
+ }> | Extract<TSESTree.TSParameterProperty, {
1075
+ type: NodeType;
1076
+ }> | Extract<TSESTree.TSPrivateKeyword, {
1077
+ type: NodeType;
1078
+ }> | Extract<TSESTree.TSPropertySignatureComputedName, {
1079
+ type: NodeType;
1080
+ }> | Extract<TSESTree.TSPropertySignatureNonComputedName, {
1081
+ type: NodeType;
1082
+ }> | Extract<TSESTree.TSProtectedKeyword, {
1083
+ type: NodeType;
1084
+ }> | Extract<TSESTree.TSPublicKeyword, {
1085
+ type: NodeType;
1086
+ }> | Extract<TSESTree.TSQualifiedName, {
1087
+ type: NodeType;
1088
+ }> | Extract<TSESTree.TSReadonlyKeyword, {
1089
+ type: NodeType;
1090
+ }> | Extract<TSESTree.TSRestType, {
1091
+ type: NodeType;
1092
+ }> | Extract<TSESTree.TSSatisfiesExpression, {
1093
+ type: NodeType;
1094
+ }> | Extract<TSESTree.TSStaticKeyword, {
1095
+ type: NodeType;
1096
+ }> | Extract<TSESTree.TSStringKeyword, {
1097
+ type: NodeType;
1098
+ }> | Extract<TSESTree.TSSymbolKeyword, {
1099
+ type: NodeType;
1100
+ }> | Extract<TSESTree.TSTemplateLiteralType, {
1101
+ type: NodeType;
1102
+ }> | Extract<TSESTree.TSThisType, {
1103
+ type: NodeType;
1104
+ }> | Extract<TSESTree.TSTupleType, {
1105
+ type: NodeType;
1106
+ }> | Extract<TSESTree.TSTypeAliasDeclaration, {
1107
+ type: NodeType;
1108
+ }> | Extract<TSESTree.TSTypeAnnotation, {
1109
+ type: NodeType;
1110
+ }> | Extract<TSESTree.TSTypeAssertion, {
1111
+ type: NodeType;
1112
+ }> | Extract<TSESTree.TSTypeLiteral, {
1113
+ type: NodeType;
1114
+ }> | Extract<TSESTree.TSTypeOperator, {
1115
+ type: NodeType;
1116
+ }> | Extract<TSESTree.TSTypeParameter, {
1117
+ type: NodeType;
1118
+ }> | Extract<TSESTree.TSTypeParameterDeclaration, {
1119
+ type: NodeType;
1120
+ }> | Extract<TSESTree.TSTypeParameterInstantiation, {
1121
+ type: NodeType;
1122
+ }> | Extract<TSESTree.TSTypePredicate, {
1123
+ type: NodeType;
1124
+ }> | Extract<TSESTree.TSTypeQuery, {
1125
+ type: NodeType;
1126
+ }> | Extract<TSESTree.TSTypeReference, {
1127
+ type: NodeType;
1128
+ }> | Extract<TSESTree.TSUndefinedKeyword, {
1129
+ type: NodeType;
1130
+ }> | Extract<TSESTree.TSUnionType, {
1131
+ type: NodeType;
1132
+ }> | Extract<TSESTree.TSUnknownKeyword, {
1133
+ type: NodeType;
1134
+ }> | Extract<TSESTree.TSVoidKeyword, {
1135
+ type: NodeType;
1136
+ }> | Extract<TSESTree.UnaryExpression, {
1137
+ type: NodeType;
1138
+ }> | Extract<TSESTree.UpdateExpression, {
1139
+ type: NodeType;
1140
+ }> | Extract<TSESTree.VariableDeclaration, {
1141
+ type: NodeType;
1142
+ }> | Extract<TSESTree.VariableDeclarator, {
1143
+ type: NodeType;
1144
+ }> | Extract<TSESTree.WhileStatement, {
1145
+ type: NodeType;
1146
+ }> | Extract<TSESTree.WithStatement, {
1147
+ type: NodeType;
1148
+ }> | Extract<TSESTree.YieldExpression, {
1149
+ type: NodeType;
1150
+ }>, Conditions extends Partial<ExtractedNode>>(nodeType: NodeType, conditions: Conditions) => (node: TSESTree.Node | null | undefined) => node is Conditions & ExtractedNode;
1151
+ export declare const isTokenOfTypeWithConditions: <TokenType extends AST_TOKEN_TYPES, ExtractedToken extends Extract<TSESTree.BooleanToken, {
1152
+ type: TokenType;
1153
+ }> | Extract<TSESTree.BlockComment, {
1154
+ type: TokenType;
1155
+ }> | Extract<TSESTree.LineComment, {
1156
+ type: TokenType;
1157
+ }> | Extract<TSESTree.IdentifierToken, {
1158
+ type: TokenType;
1159
+ }> | Extract<TSESTree.JSXIdentifierToken, {
1160
+ type: TokenType;
1161
+ }> | Extract<TSESTree.JSXTextToken, {
1162
+ type: TokenType;
1163
+ }> | Extract<TSESTree.KeywordToken, {
1164
+ type: TokenType;
1165
+ }> | Extract<TSESTree.NullToken, {
1166
+ type: TokenType;
1167
+ }> | Extract<TSESTree.NumericToken, {
1168
+ type: TokenType;
1169
+ }> | Extract<TSESTree.PunctuatorToken, {
1170
+ type: TokenType;
1171
+ }> | Extract<TSESTree.RegularExpressionToken, {
1172
+ type: TokenType;
1173
+ }> | Extract<TSESTree.StringToken, {
1174
+ type: TokenType;
1175
+ }> | Extract<TSESTree.TemplateToken, {
1176
+ type: TokenType;
1177
+ }>, Conditions extends Partial<TSESTree.Token & {
1178
+ type: TokenType;
1179
+ }>>(tokenType: TokenType, conditions: Conditions) => (token: TSESTree.Token | null | undefined) => token is Conditions & ExtractedToken;
1180
+ export declare const isNotTokenOfTypeWithConditions: <TokenType extends AST_TOKEN_TYPES, ExtractedToken extends Extract<TSESTree.BooleanToken, {
1181
+ type: TokenType;
1182
+ }> | Extract<TSESTree.BlockComment, {
1183
+ type: TokenType;
1184
+ }> | Extract<TSESTree.LineComment, {
1185
+ type: TokenType;
1186
+ }> | Extract<TSESTree.IdentifierToken, {
1187
+ type: TokenType;
1188
+ }> | Extract<TSESTree.JSXIdentifierToken, {
1189
+ type: TokenType;
1190
+ }> | Extract<TSESTree.JSXTextToken, {
1191
+ type: TokenType;
1192
+ }> | Extract<TSESTree.KeywordToken, {
1193
+ type: TokenType;
1194
+ }> | Extract<TSESTree.NullToken, {
1195
+ type: TokenType;
1196
+ }> | Extract<TSESTree.NumericToken, {
1197
+ type: TokenType;
1198
+ }> | Extract<TSESTree.PunctuatorToken, {
1199
+ type: TokenType;
1200
+ }> | Extract<TSESTree.RegularExpressionToken, {
1201
+ type: TokenType;
1202
+ }> | Extract<TSESTree.StringToken, {
1203
+ type: TokenType;
1204
+ }> | Extract<TSESTree.TemplateToken, {
1205
+ type: TokenType;
1206
+ }>, Conditions extends Partial<ExtractedToken>>(tokenType: TokenType, conditions: Conditions) => (token: TSESTree.Token | null | undefined) => token is Exclude<TSESTree.BooleanToken, Conditions & ExtractedToken> | Exclude<TSESTree.BlockComment, Conditions & ExtractedToken> | Exclude<TSESTree.LineComment, Conditions & ExtractedToken> | Exclude<TSESTree.IdentifierToken, Conditions & ExtractedToken> | Exclude<TSESTree.JSXIdentifierToken, Conditions & ExtractedToken> | Exclude<TSESTree.JSXTextToken, Conditions & ExtractedToken> | Exclude<TSESTree.KeywordToken, Conditions & ExtractedToken> | Exclude<TSESTree.NullToken, Conditions & ExtractedToken> | Exclude<TSESTree.NumericToken, Conditions & ExtractedToken> | Exclude<TSESTree.PunctuatorToken, Conditions & ExtractedToken> | Exclude<TSESTree.RegularExpressionToken, Conditions & ExtractedToken> | Exclude<TSESTree.StringToken, Conditions & ExtractedToken> | Exclude<TSESTree.TemplateToken, Conditions & ExtractedToken>;
1207
+ //# sourceMappingURL=helpers.d.ts.map