@typescript-eslint/typescript-estree 6.0.0 → 7.0.0-alpha.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/typescript-estree",
-  "version": "6.0.0",
+  "version": "7.0.0-alpha.0+6ae1fa74b",
   "description": "A parser that converts TypeScript source code into an ESTree compatible form",
   "files": [
     "dist",
@@ -52,8 +52,8 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@typescript-eslint/types": "6.0.0",
-    "@typescript-eslint/visitor-keys": "6.0.0",
+    "@typescript-eslint/types": "7.0.0-alpha.0+6ae1fa74b",
+    "@typescript-eslint/visitor-keys": "7.0.0-alpha.0+6ae1fa74b",
     "debug": "^4.3.4",
     "globby": "^11.1.0",
     "is-glob": "^4.0.3",

package/_ts4.3/dist/ast-converter.d.ts

@@ -1,9 +0,0 @@
-import type { SourceFile } from 'typescript';
-import type { ASTMaps } from './convert';
-import type { ParseSettings } from './parseSettings';
-import type { TSESTree } from './ts-estree';
-export declare function astConverter(ast: SourceFile, parseSettings: ParseSettings, shouldPreserveNodeMaps: boolean): {
-    estree: TSESTree.Program;
-    astMaps: ASTMaps;
-};
-//# sourceMappingURL=ast-converter.d.ts.map

package/_ts4.3/dist/clear-caches.d.ts

@@ -1,10 +0,0 @@
-/**
- * Clears all of the internal caches.
- * Generally you shouldn't need or want to use this.
- * Examples of intended uses:
- * - In tests to reset parser state to keep tests isolated.
- * - In custom lint tooling that iteratively lints one project at a time to prevent OOMs.
- */
-export declare function clearCaches(): void;
-export declare const clearProgramCache: typeof clearCaches;
-//# sourceMappingURL=clear-caches.d.ts.map

package/_ts4.3/dist/convert-comments.d.ts

@@ -1,11 +0,0 @@
-import * as ts from 'typescript';
-import type { TSESTree } from './ts-estree';
-/**
- * Convert all comments for the given AST.
- * @param ast the AST object
- * @param code the TypeScript code
- * @returns the converted ESTreeComment
- * @private
- */
-export declare function convertComments(ast: ts.SourceFile, code: string): TSESTree.Comment[];
-//# sourceMappingURL=convert-comments.d.ts.map

package/_ts4.3/dist/convert.d.ts

@@ -1,142 +0,0 @@
-import * as ts from 'typescript';
-import type { TSError } from './node-utils';
-import type { ParserWeakMap, ParserWeakMapESTreeToTSNode } from './parser-options';
-import type { SemanticOrSyntacticError } from './semantic-or-syntactic-errors';
-import type { TSESTree, TSNode } from './ts-estree';
-export interface ConverterOptions {
-    allowInvalidAST?: boolean;
-    errorOnUnknownASTType?: boolean;
-    shouldPreserveNodeMaps?: boolean;
-    suppressDeprecatedPropertyWarnings?: boolean;
-}
-/**
- * Extends and formats a given error object
- * @param error the error object
- * @returns converted error object
- */
-export declare function convertError(error: SemanticOrSyntacticError | ts.DiagnosticWithLocation): TSError;
-export interface ASTMaps {
-    esTreeNodeToTSNodeMap: ParserWeakMapESTreeToTSNode;
-    tsNodeToESTreeNodeMap: ParserWeakMap<TSNode, TSESTree.Node>;
-}
-export declare class Converter {
-    #private;
-    private readonly ast;
-    private readonly options;
-    private readonly esTreeNodeToTSNodeMap;
-    private readonly tsNodeToESTreeNodeMap;
-    private allowPattern;
-    /**
-     * Converts a TypeScript node into an ESTree node
-     * @param ast the full TypeScript AST
-     * @param options additional options for the conversion
-     * @returns the converted ESTreeNode
-     */
-    constructor(ast: ts.SourceFile, options?: ConverterOptions);
-    getASTMaps(): ASTMaps;
-    convertProgram(): TSESTree.Program;
-    /**
-     * Converts a TypeScript node into an ESTree node.
-     * @param node the child ts.Node
-     * @param parent parentNode
-     * @param allowPattern flag to determine if patterns are allowed
-     * @returns the converted ESTree node
-     */
-    private converter;
-    /**
-     * Fixes the exports of the given ts.Node
-     * @param node the ts.Node
-     * @param result result
-     * @returns the ESTreeNode with fixed exports
-     */
-    private fixExports;
-    /**
-     * Register specific TypeScript node into map with first ESTree node provided
-     */
-    private registerTSNodeInNodeMap;
-    /**
-     * Converts a TypeScript node into an ESTree node.
-     * @param child the child ts.Node
-     * @param parent parentNode
-     * @returns the converted ESTree node
-     */
-    private convertPattern;
-    /**
-     * Converts a TypeScript node into an ESTree node.
-     * @param child the child ts.Node
-     * @param parent parentNode
-     * @returns the converted ESTree node
-     */
-    private convertChild;
-    private createNode;
-    private convertBindingNameWithTypeAnnotation;
-    /**
-     * Converts a child into a type annotation. This creates an intermediary
-     * TypeAnnotation node to match what Flow does.
-     * @param child The TypeScript AST node to convert.
-     * @param parent parentNode
-     * @returns The type annotation node.
-     */
-    private convertTypeAnnotation;
-    /**
-     * Coverts body Nodes and add a directive field to StringLiterals
-     * @param nodes of ts.Node
-     * @param parent parentNode
-     * @returns Array of body statements
-     */
-    private convertBodyExpressions;
-    /**
-     * Converts a ts.Node's typeArguments to TSTypeParameterInstantiation node
-     * @param typeArguments ts.NodeArray typeArguments
-     * @param node parent used to create this node
-     * @returns TypeParameterInstantiation node
-     */
-    private convertTypeArgumentsToTypeParameterInstantiation;
-    /**
-     * Converts a ts.Node's typeParameters to TSTypeParameterDeclaration node
-     * @param typeParameters ts.Node typeParameters
-     * @returns TypeParameterDeclaration node
-     */
-    private convertTSTypeParametersToTypeParametersDeclaration;
-    /**
-     * Converts an array of ts.Node parameters into an array of ESTreeNode params
-     * @param parameters An array of ts.Node params to be converted
-     * @returns an array of converted ESTreeNode params
-     */
-    private convertParameters;
-    private convertChainExpression;
-    /**
-     * For nodes that are copied directly from the TypeScript AST into
-     * ESTree mostly as-is. The only difference is the addition of a type
-     * property instead of a kind property. Recursively copies all children.
-     */
-    private deeplyCopy;
-    private convertJSXIdentifier;
-    private convertJSXNamespaceOrIdentifier;
-    /**
-     * Converts a TypeScript JSX node.tagName into an ESTree node.name
-     * @param node the tagName object from a JSX ts.Node
-     * @param parent
-     * @returns the converted ESTree name object
-     */
-    private convertJSXTagName;
-    private convertMethodSignature;
-    private convertAssertClasue;
-    /**
-     * Uses the provided range location to adjust the location data of the given Node
-     * @param result The node that will have its location data mutated
-     * @param childRange The child node range used to expand location
-     */
-    private fixParentLocation;
-    private assertModuleSpecifier;
-    /**
-     * Converts a TypeScript node into an ESTree node.
-     * The core of the conversion logic:
-     * Identify and convert each relevant TypeScript SyntaxKind
-     * @param node the child ts.Node
-     * @param parent parentNode
-     * @returns the converted ESTree node
-     */
-    private convertNode;
-}
-//# sourceMappingURL=convert.d.ts.map

package/_ts4.3/dist/create-program/WatchCompilerHostOfConfigFile.d.ts

@@ -1,13 +0,0 @@
-import type * as ts from 'typescript';
-interface DirectoryStructureHost {
-    readDirectory?(path: string, extensions?: readonly string[], exclude?: readonly string[], include?: readonly string[], depth?: number): string[];
-}
-interface CachedDirectoryStructureHost extends DirectoryStructureHost {
-    readDirectory(path: string, extensions?: readonly string[], exclude?: readonly string[], include?: readonly string[], depth?: number): string[];
-}
-interface WatchCompilerHostOfConfigFile<T extends ts.BuilderProgram> extends ts.WatchCompilerHostOfConfigFile<T> {
-    onCachedDirectoryStructureHostCreate(host: CachedDirectoryStructureHost): void;
-    extraFileExtensions?: readonly ts.FileExtensionInfo[];
-}
-export { WatchCompilerHostOfConfigFile };
-//# sourceMappingURL=WatchCompilerHostOfConfigFile.d.ts.map

package/_ts4.3/dist/create-program/createDefaultProgram.d.ts

@@ -1,12 +0,0 @@
-import type { ParseSettings } from '../parseSettings';
-import type { ASTAndDefiniteProgram } from './shared';
-/**
- * @param parseSettings Internal settings for parsing the file
- * @returns If found, returns the source file corresponding to the code and the containing program
- * @deprecated
- * This is a legacy option that comes with severe performance penalties.
- * Please do not use it.
- */
-declare function createDefaultProgram(parseSettings: ParseSettings): ASTAndDefiniteProgram | undefined;
-export { createDefaultProgram };
-//# sourceMappingURL=createDefaultProgram.d.ts.map

package/_ts4.3/dist/create-program/createIsolatedProgram.d.ts

@@ -1,9 +0,0 @@
-import type { ParseSettings } from '../parseSettings';
-import type { ASTAndDefiniteProgram } from './shared';
-/**
- * @param code The code of the file being linted
- * @returns Returns a new source file and program corresponding to the linted code
- */
-declare function createIsolatedProgram(parseSettings: ParseSettings): ASTAndDefiniteProgram;
-export { createIsolatedProgram };
-//# sourceMappingURL=createIsolatedProgram.d.ts.map

package/_ts4.3/dist/create-program/createProjectProgram.d.ts

@@ -1,9 +0,0 @@
-import type { ParseSettings } from '../parseSettings';
-import type { ASTAndDefiniteProgram } from './shared';
-/**
- * @param parseSettings Internal settings for parsing the file
- * @returns If found, the source file corresponding to the code and the containing program
- */
-declare function createProjectProgram(parseSettings: ParseSettings): ASTAndDefiniteProgram | undefined;
-export { createProjectProgram };
-//# sourceMappingURL=createProjectProgram.d.ts.map

package/_ts4.3/dist/create-program/createSourceFile.d.ts

@@ -1,7 +0,0 @@
-import * as ts from 'typescript';
-import type { ParseSettings } from '../parseSettings';
-import type { ASTAndNoProgram } from './shared';
-declare function createSourceFile(parseSettings: ParseSettings): ts.SourceFile;
-declare function createNoProgram(parseSettings: ParseSettings): ASTAndNoProgram;
-export { createSourceFile, createNoProgram };
-//# sourceMappingURL=createSourceFile.d.ts.map

package/_ts4.3/dist/create-program/describeFilePath.d.ts

@@ -1,2 +0,0 @@
-export declare function describeFilePath(filePath: string, tsconfigRootDir: string): string;
-//# sourceMappingURL=describeFilePath.d.ts.map

package/_ts4.3/dist/create-program/getScriptKind.d.ts

@@ -1,5 +0,0 @@
-import * as ts from 'typescript';
-declare function getScriptKind(filePath: string, jsx: boolean): ts.ScriptKind;
-declare function getLanguageVariant(scriptKind: ts.ScriptKind): ts.LanguageVariant;
-export { getScriptKind, getLanguageVariant };
-//# sourceMappingURL=getScriptKind.d.ts.map

package/_ts4.3/dist/create-program/getWatchProgramsForProjects.d.ts

@@ -1,15 +0,0 @@
-import * as ts from 'typescript';
-import type { ParseSettings } from '../parseSettings';
-/**
- * Clear all of the parser caches.
- * This should only be used in testing to ensure the parser is clean between tests.
- */
-declare function clearWatchCaches(): void;
-/**
- * Calculate project environments using options provided by consumer and paths from config
- * @param parseSettings Internal settings for parsing the file
- * @returns The programs corresponding to the supplied tsconfig paths
- */
-declare function getWatchProgramsForProjects(parseSettings: ParseSettings): ts.Program[];
-export { clearWatchCaches, getWatchProgramsForProjects };
-//# sourceMappingURL=getWatchProgramsForProjects.d.ts.map

package/_ts4.3/dist/create-program/shared.d.ts

@@ -1,32 +0,0 @@
-import type { Program } from 'typescript';
-import * as ts from 'typescript';
-import type { ParseSettings } from '../parseSettings';
-interface ASTAndNoProgram {
-    ast: ts.SourceFile;
-    program: null;
-}
-interface ASTAndDefiniteProgram {
-    ast: ts.SourceFile;
-    program: ts.Program;
-}
-type ASTAndProgram = ASTAndDefiniteProgram | ASTAndNoProgram;
-/**
- * Compiler options required to avoid critical functionality issues
- */
-declare const CORE_COMPILER_OPTIONS: ts.CompilerOptions;
-declare function createDefaultCompilerOptionsFromExtra(parseSettings: ParseSettings): ts.CompilerOptions;
-type CanonicalPath = string & {
-    __brand: unknown;
-};
-declare function getCanonicalFileName(filePath: string): CanonicalPath;
-declare function ensureAbsolutePath(p: string, tsconfigRootDir: string): string;
-declare function canonicalDirname(p: CanonicalPath): CanonicalPath;
-declare function getAstFromProgram(currentProgram: Program, parseSettings: ParseSettings): ASTAndDefiniteProgram | undefined;
-/**
- * Hash content for compare content.
- * @param content hashed contend
- * @returns hashed result
- */
-declare function createHash(content: string): string;
-export { ASTAndDefiniteProgram, ASTAndNoProgram, ASTAndProgram, CORE_COMPILER_OPTIONS, canonicalDirname, CanonicalPath, createDefaultCompilerOptionsFromExtra, createHash, ensureAbsolutePath, getCanonicalFileName, getAstFromProgram, };
-//# sourceMappingURL=shared.d.ts.map

package/_ts4.3/dist/create-program/useProvidedPrograms.d.ts

@@ -1,13 +0,0 @@
-import * as ts from 'typescript';
-import type { ParseSettings } from '../parseSettings';
-import type { ASTAndDefiniteProgram } from './shared';
-declare function useProvidedPrograms(programInstances: Iterable<ts.Program>, parseSettings: ParseSettings): ASTAndDefiniteProgram | undefined;
-/**
- * Utility offered by parser to help consumers construct their own program instance.
- *
- * @param configFile the path to the tsconfig.json file, relative to `projectDirectory`
- * @param projectDirectory the project directory to use as the CWD, defaults to `process.cwd()`
- */
-declare function createProgramFromConfigFile(configFile: string, projectDirectory?: string): ts.Program;
-export { useProvidedPrograms, createProgramFromConfigFile };
-//# sourceMappingURL=useProvidedPrograms.d.ts.map

package/_ts4.3/dist/createParserServices.d.ts

@@ -1,5 +0,0 @@
-import type * as ts from 'typescript';
-import type { ASTMaps } from './convert';
-import type { ParserServices } from './parser-options';
-export declare function createParserServices(astMaps: ASTMaps, program: ts.Program | null): ParserServices;
-//# sourceMappingURL=createParserServices.d.ts.map

package/_ts4.3/dist/getModifiers.d.ts

@@ -1,4 +0,0 @@
-import * as ts from 'typescript';
-export declare function getModifiers(node: ts.Node | null | undefined, includeIllegalModifiers?: boolean): ts.Modifier[] | undefined;
-export declare function getDecorators(node: ts.Node | null | undefined, includeIllegalDecorators?: boolean): ts.Decorator[] | undefined;
-//# sourceMappingURL=getModifiers.d.ts.map

package/_ts4.3/dist/index.d.ts

@@ -1,13 +0,0 @@
-export { AST, parse, parseAndGenerateServices, ParseAndGenerateServicesResult, } from './parser';
-export { ParserServices, ParserServicesWithTypeInformation, ParserServicesWithoutTypeInformation, TSESTreeOptions, } from './parser-options';
-export { simpleTraverse } from './simple-traverse';
-export * from './ts-estree';
-export { createProgramFromConfigFile as createProgram } from './create-program/useProvidedPrograms';
-export * from './create-program/getScriptKind';
-export { getCanonicalFileName } from './create-program/shared';
-export { typescriptVersionIsAtLeast } from './version-check';
-export * from './getModifiers';
-export { TSError } from './node-utils';
-export * from './clear-caches';
-export declare const version: string;
-//# sourceMappingURL=index.d.ts.map

package/_ts4.3/dist/jsx/xhtml-entities.d.ts

@@ -1,2 +0,0 @@
-export declare const xhtmlEntities: Record<string, string>;
-//# sourceMappingURL=xhtml-entities.d.ts.map

package/_ts4.3/dist/node-utils.d.ts

@@ -1,254 +0,0 @@
-import * as ts from 'typescript';
-import type { TSESTree, TSNode } from './ts-estree';
-import { AST_NODE_TYPES, AST_TOKEN_TYPES } from './ts-estree';
-declare const SyntaxKind: typeof ts.SyntaxKind;
-type LogicalOperatorKind = ts.SyntaxKind.AmpersandAmpersandToken | ts.SyntaxKind.BarBarToken | ts.SyntaxKind.QuestionQuestionToken;
-interface TokenToText extends TSESTree.PunctuatorTokenToText, TSESTree.BinaryOperatorToText {
-    [SyntaxKind.ImportKeyword]: 'import';
-    [SyntaxKind.NewKeyword]: 'new';
-    [SyntaxKind.KeyOfKeyword]: 'keyof';
-    [SyntaxKind.ReadonlyKeyword]: 'readonly';
-    [SyntaxKind.UniqueKeyword]: 'unique';
-}
-type AssignmentOperatorKind = keyof TSESTree.AssignmentOperatorToText;
-type BinaryOperatorKind = keyof TSESTree.BinaryOperatorToText;
-/**
- * Returns true if the given ts.Token is a logical operator
- * @param operator the operator token
- * @returns is a logical operator
- */
-export declare function isLogicalOperator(operator: ts.BinaryOperatorToken): operator is ts.Token<LogicalOperatorKind>;
-export declare function isESTreeBinaryOperator(operator: ts.BinaryOperatorToken): operator is ts.Token<BinaryOperatorKind>;
-type TokenForTokenKind<T extends ts.SyntaxKind> = T extends keyof TokenToText ? TokenToText[T] : string | undefined;
-/**
- * Returns the string form of the given TSToken SyntaxKind
- * @param kind the token's SyntaxKind
- * @returns the token applicable token as a string
- */
-export declare function getTextForTokenKind<T extends ts.SyntaxKind>(kind: T): TokenForTokenKind<T>;
-/**
- * Returns true if the given ts.Node is a valid ESTree class member
- * @param node TypeScript AST node
- * @returns is valid ESTree class member
- */
-export declare function isESTreeClassMember(node: ts.Node): boolean;
-/**
- * Checks if a ts.Node has a modifier
- * @param modifierKind TypeScript SyntaxKind modifier
- * @param node TypeScript AST node
- * @returns has the modifier specified
- */
-export declare function hasModifier(modifierKind: ts.KeywordSyntaxKind, node: ts.Node): boolean;
-/**
- * Get last last modifier in ast
- * @param node TypeScript AST node
- * @returns returns last modifier if present or null
- */
-export declare function getLastModifier(node: ts.Node): ts.Modifier | null;
-/**
- * Returns true if the given ts.Token is a comma
- * @param token the TypeScript token
- * @returns is comma
- */
-export declare function isComma(token: ts.Node): token is ts.Token<ts.SyntaxKind.CommaToken>;
-/**
- * Returns true if the given ts.Node is a comment
- * @param node the TypeScript node
- * @returns is comment
- */
-export declare function isComment(node: ts.Node): boolean;
-/**
- * Returns the binary expression type of the given ts.Token
- * @param operator the operator token
- * @returns the binary expression type
- */
-export declare function getBinaryExpressionType(operator: ts.BinaryOperatorToken): {
-    type: AST_NODE_TYPES.AssignmentExpression;
-    operator: TokenForTokenKind<AssignmentOperatorKind>;
-} | {
-    type: AST_NODE_TYPES.BinaryExpression;
-    operator: TokenForTokenKind<BinaryOperatorKind>;
-} | {
-    type: AST_NODE_TYPES.LogicalExpression;
-    operator: TokenForTokenKind<LogicalOperatorKind>;
-};
-/**
- * Returns line and column data for the given positions,
- * @param pos position to check
- * @param ast the AST object
- * @returns line and column
- */
-export declare function getLineAndCharacterFor(pos: number, ast: ts.SourceFile): TSESTree.Position;
-/**
- * Returns line and column data for the given start and end positions,
- * for the given AST
- * @param range start end data
- * @param ast   the AST object
- * @returns the loc data
- */
-export declare function getLocFor(range: TSESTree.Range, ast: ts.SourceFile): TSESTree.SourceLocation;
-/**
- * Check whatever node can contain directive
- * @param node
- * @returns returns true if node can contain directive
- */
-export declare function canContainDirective(node: ts.Block | ts.ClassStaticBlockDeclaration | ts.ModuleBlock | ts.SourceFile): boolean;
-/**
- * Returns range for the given ts.Node
- * @param node the ts.Node or ts.Token
- * @param ast the AST object
- * @returns the range data
- */
-export declare function getRange(node: Pick<ts.Node, 'getEnd' | 'getStart'>, ast: ts.SourceFile): [
-    number,
-    number
-];
-/**
- * Returns true if a given ts.Node is a JSX token
- * @param node ts.Node to be checked
- * @returns is a JSX token
- */
-export declare function isJSXToken(node: ts.Node): boolean;
-/**
- * Returns the declaration kind of the given ts.Node
- * @param node TypeScript AST node
- * @returns declaration kind
- */
-export declare function getDeclarationKind(node: ts.VariableDeclarationList): 'const' | 'let' | 'var';
-/**
- * Gets a ts.Node's accessibility level
- * @param node The ts.Node
- * @returns accessibility "public", "protected", "private", or null
- */
-export declare function getTSNodeAccessibility(node: ts.Node): 'private' | 'protected' | 'public' | undefined;
-/**
- * Finds the next token based on the previous one and its parent
- * Had to copy this from TS instead of using TS's version because theirs doesn't pass the ast to getChildren
- * @param previousToken The previous TSToken
- * @param parent The parent TSNode
- * @param ast The TS AST
- * @returns the next TSToken
- */
-export declare function findNextToken(previousToken: ts.TextRange, parent: ts.Node, ast: ts.SourceFile): ts.Node | undefined;
-/**
- * Find the first matching ancestor based on the given predicate function.
- * @param node The current ts.Node
- * @param predicate The predicate function to apply to each checked ancestor
- * @returns a matching parent ts.Node
- */
-export declare function findFirstMatchingAncestor(node: ts.Node, predicate: (node: ts.Node) => boolean): ts.Node | undefined;
-/**
- * Returns true if a given ts.Node has a JSX token within its hierarchy
- * @param node ts.Node to be checked
- * @returns has JSX ancestor
- */
-export declare function hasJSXAncestor(node: ts.Node): boolean;
-/**
- * Unescape the text content of string literals, e.g. &amp; -> &
- * @param text The escaped string literal text.
- * @returns The unescaped string literal text.
- */
-export declare function unescapeStringLiteralText(text: string): string;
-/**
- * Returns true if a given ts.Node is a computed property
- * @param node ts.Node to be checked
- * @returns is Computed Property
- */
-export declare function isComputedProperty(node: ts.Node): node is ts.ComputedPropertyName;
-/**
- * Returns true if a given ts.Node is optional (has QuestionToken)
- * @param node ts.Node to be checked
- * @returns is Optional
- */
-export declare function isOptional(node: {
-    questionToken?: ts.QuestionToken;
-}): boolean;
-/**
- * Returns true if the node is an optional chain node
- */
-export declare function isChainExpression(node: TSESTree.Node): node is TSESTree.ChainExpression;
-/**
- * Returns true of the child of property access expression is an optional chain
- */
-export declare function isChildUnwrappableOptionalChain(node: ts.CallExpression | ts.ElementAccessExpression | ts.NonNullExpression | ts.PropertyAccessExpression, child: TSESTree.Node): boolean;
-/**
- * Returns the type of a given ts.Token
- * @param token the ts.Token
- * @returns the token type
- */
-export declare function getTokenType(token: ts.Identifier | ts.Token<ts.SyntaxKind>): Exclude<AST_TOKEN_TYPES, AST_TOKEN_TYPES.Block | AST_TOKEN_TYPES.Line>;
-/**
- * Extends and formats a given ts.Token, for a given AST
- * @param token the ts.Token
- * @param ast   the AST object
- * @returns the converted Token
- */
-export declare function convertToken(token: ts.Token<ts.TokenSyntaxKind>, ast: ts.SourceFile): TSESTree.Token;
-/**
- * Converts all tokens for the given AST
- * @param ast the AST object
- * @returns the converted Tokens
- */
-export declare function convertTokens(ast: ts.SourceFile): TSESTree.Token[];
-export declare class TSError extends Error {
-    readonly fileName: string;
-    readonly location: {
-        start: {
-            line: number;
-            column: number;
-            offset: number;
-        };
-        end: {
-            line: number;
-            column: number;
-            offset: number;
-        };
-    };
-    constructor(message: string, fileName: string, location: {
-        start: {
-            line: number;
-            column: number;
-            offset: number;
-        };
-        end: {
-            line: number;
-            column: number;
-            offset: number;
-        };
-    });
-    get index(): number;
-    get lineNumber(): number;
-    get column(): number;
-}
-/**
- * @param message the error message
- * @param ast the AST object
- * @param startIndex the index at which the error starts
- * @param endIndex the index at which the error ends
- * @returns converted error object
- */
-export declare function createError(message: string, ast: ts.SourceFile, startIndex: number, endIndex?: number): TSError;
-export declare function nodeHasIllegalDecorators(node: ts.Node): node is ts.Node & {
-    illegalDecorators: ts.Node[];
-};
-/**
- * @param n the TSNode
- * @param ast the TS AST
- */
-export declare function nodeHasTokens(n: ts.Node, ast: ts.SourceFile): boolean;
-/**
- * Like `forEach`, but suitable for use with numbers and strings (which may be falsy).
- * @template T
- * @template U
- * @param array
- * @param callback
- */
-export declare function firstDefined<T, U>(array: readonly T[] | undefined, callback: (element: T, index: number) => U | undefined): U | undefined;
-export declare function identifierIsThisKeyword(id: ts.Identifier): boolean;
-export declare function isThisIdentifier(node: ts.Node | undefined): node is ts.Identifier;
-export declare function isThisInTypeQuery(node: ts.Node): boolean;
-export declare function nodeIsPresent(node: ts.Node | undefined): node is ts.Node;
-export declare function getContainingFunction(node: ts.Node): ts.SignatureDeclaration | undefined;
-export declare function nodeCanBeDecorated(node: TSNode): boolean;
-export {};
-//# sourceMappingURL=node-utils.d.ts.map

package/_ts4.3/dist/parseSettings/ExpiringCache.d.ts

@@ -1,17 +0,0 @@
-import type { CacheDurationSeconds } from '@typescript-eslint/types';
-export declare const DEFAULT_TSCONFIG_CACHE_DURATION_SECONDS = 30;
-export interface CacheLike<Key, Value> {
-    get(key: Key): Value | void;
-    set(key: Key, value: Value): this;
-}
-/**
- * A map with key-level expiration.
- */
-export declare class ExpiringCache<TKey, TValue> implements CacheLike<TKey, TValue> {
-    #private;
-    constructor(cacheDurationSeconds: CacheDurationSeconds);
-    set(key: TKey, value: TValue): this;
-    get(key: TKey): TValue | undefined;
-    clear(): void;
-}
-//# sourceMappingURL=ExpiringCache.d.ts.map

package/_ts4.3/dist/parseSettings/createParseSettings.d.ts

@@ -1,6 +0,0 @@
-import type * as ts from 'typescript';
-import type { TSESTreeOptions } from '../parser-options';
-import type { MutableParseSettings } from './index';
-export declare function createParseSettings(code: ts.SourceFile | string, options?: Partial<TSESTreeOptions>): MutableParseSettings;
-export declare function clearTSConfigMatchCache(): void;
-//# sourceMappingURL=createParseSettings.d.ts.map

package/_ts4.3/dist/parseSettings/getProjectConfigFiles.d.ts

@@ -1,12 +0,0 @@
-import type { ParseSettings } from '.';
-/**
- * Checks for a matching TSConfig to a file including its parent directories,
- * permanently caching results under each directory it checks.
- *
- * @remarks
- * We don't (yet!) have a way to attach file watchers on disk, but still need to
- * cache file checks for rapid subsequent calls to fs.existsSync. See discussion
- * in https://github.com/typescript-eslint/typescript-eslint/issues/101.
- */
-export declare function getProjectConfigFiles(parseSettings: Pick<ParseSettings, 'filePath' | 'tsconfigMatchCache' | 'tsconfigRootDir'>, project: string[] | string | true | null | undefined): string[] | null;
-//# sourceMappingURL=getProjectConfigFiles.d.ts.map