@sprucelabs/spruce-cli 17.1.47 → 17.1.48

package/node_modules/@typescript-eslint/types/_ts3.4/dist/index.d.ts

@@ -1,5 +0,0 @@
-export { AST_NODE_TYPES, AST_TOKEN_TYPES } from './generated/ast-spec';
-export * from './lib';
-export * from './parser-options';
-export * from './ts-estree';
-//# sourceMappingURL=index.d.ts.map

package/node_modules/@typescript-eslint/types/_ts3.4/dist/lib.d.ts

@@ -1,3 +0,0 @@
-declare type Lib = 'es5' | 'es6' | 'es2015' | 'es7' | 'es2016' | 'es2017' | 'es2018' | 'es2019' | 'es2020' | 'es2021' | 'es2022' | 'esnext' | 'dom' | 'dom.iterable' | 'webworker' | 'webworker.importscripts' | 'webworker.iterable' | 'scripthost' | 'es2015.core' | 'es2015.collection' | 'es2015.generator' | 'es2015.iterable' | 'es2015.promise' | 'es2015.proxy' | 'es2015.reflect' | 'es2015.symbol' | 'es2015.symbol.wellknown' | 'es2016.array.include' | 'es2017.object' | 'es2017.sharedmemory' | 'es2017.string' | 'es2017.intl' | 'es2017.typedarrays' | 'es2018.asyncgenerator' | 'es2018.asynciterable' | 'es2018.intl' | 'es2018.promise' | 'es2018.regexp' | 'es2019.array' | 'es2019.object' | 'es2019.string' | 'es2019.symbol' | 'es2020.bigint' | 'es2020.date' | 'es2020.promise' | 'es2020.sharedmemory' | 'es2020.string' | 'es2020.symbol.wellknown' | 'es2020.intl' | 'es2020.number' | 'es2021.promise' | 'es2021.string' | 'es2021.weakref' | 'es2021.intl' | 'es2022.array' | 'es2022.error' | 'es2022.intl' | 'es2022.object' | 'es2022.sharedmemory' | 'es2022.string' | 'esnext.array' | 'esnext.symbol' | 'esnext.asynciterable' | 'esnext.intl' | 'esnext.bigint' | 'esnext.string' | 'esnext.promise' | 'esnext.weakref' | 'es2016.full' | 'es2017.full' | 'es2018.full' | 'es2019.full' | 'es2020.full' | 'es2021.full' | 'es2022.full' | 'esnext.full' | 'lib';
-export { Lib };
-//# sourceMappingURL=lib.d.ts.map

package/node_modules/@typescript-eslint/types/_ts3.4/dist/parser-options.d.ts

@@ -1,36 +0,0 @@
-import { Program } from 'typescript';
-import { Lib } from './lib';
-declare type DebugLevel = boolean | ('typescript-eslint' | 'eslint' | 'typescript')[];
-declare type EcmaVersion = 3 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 2015 | 2016 | 2017 | 2018 | 2019 | 2020 | 2021 | 2022;
-declare type SourceType = 'script' | 'module';
-interface ParserOptions {
-    ecmaFeatures?: {
-        globalReturn?: boolean;
-        jsx?: boolean;
-    };
-    ecmaVersion?: EcmaVersion | 'latest';
-    jsxPragma?: string | null;
-    jsxFragmentName?: string | null;
-    lib?: Lib[];
-    emitDecoratorMetadata?: boolean;
-    comment?: boolean;
-    debugLevel?: DebugLevel;
-    errorOnTypeScriptSyntacticAndSemanticIssues?: boolean;
-    errorOnUnknownASTType?: boolean;
-    EXPERIMENTAL_useSourceOfProjectReferenceRedirect?: boolean;
-    extraFileExtensions?: string[];
-    filePath?: string;
-    loc?: boolean;
-    program?: Program;
-    project?: string | string[];
-    projectFolderIgnoreList?: (string | RegExp)[];
-    range?: boolean;
-    sourceType?: SourceType;
-    tokens?: boolean;
-    tsconfigRootDir?: string;
-    warnOnUnsupportedTypeScriptVersion?: boolean;
-    moduleResolver?: string;
-    [additionalProperties: string]: unknown;
-}
-export { DebugLevel, EcmaVersion, ParserOptions, SourceType };
-//# sourceMappingURL=parser-options.d.ts.map

package/node_modules/@typescript-eslint/types/_ts3.4/dist/ts-estree.d.ts

@@ -1,9 +0,0 @@
-import * as TSESTree from './generated/ast-spec';
-declare module './generated/ast-spec' {
-    interface BaseNode {
-        parent?: TSESTree.Node;
-    }
-}
-import * as TSESTree_1 from './generated/ast-spec';
-export { TSESTree_1 as TSESTree };
-//# sourceMappingURL=ts-estree.d.ts.map

package/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/ast-converter.d.ts

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

package/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/convert-comments.d.ts

@@ -1,11 +0,0 @@
-import * as ts from 'typescript';
-import { 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/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/convert.d.ts

@@ -1,159 +0,0 @@
-import * as ts from 'typescript';
-import { TSError } from './node-utils';
-import { ParserWeakMap, ParserWeakMapESTreeToTSNode } from './parser-options';
-import { SemanticOrSyntacticError } from './semantic-or-syntactic-errors';
-import { TSESTree, TSNode } from './ts-estree';
-interface ConverterOptions {
-    errorOnUnknownASTType: boolean;
-    shouldPreserveNodeMaps: boolean;
-}
-/**
- * Extends and formats a given error object
- * @param error the error object
- * @returns converted error object
- */
-export declare function convertError(error: ts.DiagnosticWithLocation | SemanticOrSyntacticError): TSError;
-export interface ASTMaps {
-    esTreeNodeToTSNodeMap: ParserWeakMapESTreeToTSNode;
-    tsNodeToESTreeNodeMap: ParserWeakMap<TSNode, TSESTree.Node>;
-}
-export declare class Converter {
-    private readonly ast;
-    private readonly options;
-    private readonly esTreeNodeToTSNodeMap;
-    private readonly tsNodeToESTreeNodeMap;
-    private allowPattern;
-    private inTypeMode;
-    /**
-     * 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 inTypeMode flag to determine if we are in typeMode
-     * @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;
-    /**
-     * Converts a TypeScript node into an ESTree node.
-     * @param child the child ts.Node
-     * @param parent parentNode
-     * @returns the converted ESTree node
-     */
-    private convertType;
-    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 convertTypeArgumentsToTypeParameters;
-    /**
-     * 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;
-    /**
-     * Applies the given TS modifiers to the given result object.
-     *
-     * This method adds not standardized `modifiers` property in nodes
-     *
-     * @param result
-     * @param modifiers original ts.Nodes from the node.modifiers array
-     * @returns the current result object will be mutated
-     */
-    private applyModifiersToResult;
-    /**
-     * 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;
-}
-export {};
-//# sourceMappingURL=convert.d.ts.map

package/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/create-program/WatchCompilerHostOfConfigFile.d.ts

@@ -1,13 +0,0 @@
-import * as ts from 'typescript';
-interface DirectoryStructureHost {
-    readDirectory?(path: string, extensions?: ReadonlyArray<string>, exclude?: ReadonlyArray<string>, include?: ReadonlyArray<string>, depth?: number): string[];
-}
-interface CachedDirectoryStructureHost extends DirectoryStructureHost {
-    readDirectory(path: string, extensions?: ReadonlyArray<string>, exclude?: ReadonlyArray<string>, include?: ReadonlyArray<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/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/create-program/createDefaultProgram.d.ts

@@ -1,12 +0,0 @@
-import { Extra } from '../parser-options';
-import { ASTAndProgram } from './shared';
-/**
- * @param code The code of the file being linted
- * @param extra The config object
- * @param extra.tsconfigRootDir The root directory for relative tsconfig paths
- * @param extra.projects Provided tsconfig paths
- * @returns If found, returns the source file corresponding to the code and the containing program
- */
-declare function createDefaultProgram(code: string, extra: Extra): ASTAndProgram | undefined;
-export { createDefaultProgram };
-//# sourceMappingURL=createDefaultProgram.d.ts.map

package/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/create-program/createIsolatedProgram.d.ts

@@ -1,9 +0,0 @@
-import { Extra } from '../parser-options';
-import { ASTAndProgram } 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(code: string, extra: Extra): ASTAndProgram;
-export { createIsolatedProgram };
-//# sourceMappingURL=createIsolatedProgram.d.ts.map

package/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/create-program/createProjectProgram.d.ts

@@ -1,11 +0,0 @@
-import { Extra } from '../parser-options';
-import { ASTAndProgram } from './shared';
-/**
- * @param code The code of the file being linted
- * @param createDefaultProgram True if the default program should be created
- * @param extra The config object
- * @returns If found, returns the source file corresponding to the code and the containing program
- */
-declare function createProjectProgram(code: string, createDefaultProgram: boolean, extra: Extra): ASTAndProgram | undefined;
-export { createProjectProgram };
-//# sourceMappingURL=createProjectProgram.d.ts.map

package/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/create-program/createSourceFile.d.ts

@@ -1,5 +0,0 @@
-import * as ts from 'typescript';
-import { Extra } from '../parser-options';
-declare function createSourceFile(code: string, extra: Extra): ts.SourceFile;
-export { createSourceFile };
-//# sourceMappingURL=createSourceFile.d.ts.map

package/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/create-program/createWatchProgram.d.ts

@@ -1,19 +0,0 @@
-import * as ts from 'typescript';
-import { Extra } from '../parser-options';
-/**
- * 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 code The code being linted
- * @param filePathIn The path of the file being parsed
- * @param extra.tsconfigRootDir The root directory for relative tsconfig paths
- * @param extra.projects Provided tsconfig paths
- * @returns The programs corresponding to the supplied tsconfig paths
- */
-declare function getProgramsForProjects(code: string, filePathIn: string, extra: Extra): ts.Program[];
-declare function createWatchProgram(tsconfigPath: string, extra: Extra): ts.WatchOfConfigFile<ts.BuilderProgram>;
-export { clearWatchCaches, createWatchProgram, getProgramsForProjects };
-//# sourceMappingURL=createWatchProgram.d.ts.map

package/node_modules/@typescript-eslint/typescript-estree/_ts3.4/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/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/create-program/shared.d.ts

@@ -1,22 +0,0 @@
-import { Program } from 'typescript';
-import * as ts from 'typescript';
-import { Extra, ModuleResolver } from '../parser-options';
-interface ASTAndProgram {
-    ast: ts.SourceFile;
-    program: ts.Program;
-}
-/**
- * Compiler options required to avoid critical functionality issues
- */
-declare const CORE_COMPILER_OPTIONS: ts.CompilerOptions;
-declare function createDefaultCompilerOptionsFromExtra(extra: Extra): ts.CompilerOptions;
-declare type CanonicalPath = string & {
-    __brand: unknown;
-};
-declare function getCanonicalFileName(filePath: string): CanonicalPath;
-declare function ensureAbsolutePath(p: string, extra: Extra): string;
-declare function canonicalDirname(p: CanonicalPath): CanonicalPath;
-declare function getAstFromProgram(currentProgram: Program, extra: Extra): ASTAndProgram | undefined;
-declare function getModuleResolver(moduleResolverPath: string): ModuleResolver;
-export { ASTAndProgram, CORE_COMPILER_OPTIONS, canonicalDirname, CanonicalPath, createDefaultCompilerOptionsFromExtra, ensureAbsolutePath, getCanonicalFileName, getAstFromProgram, getModuleResolver, };
-//# sourceMappingURL=shared.d.ts.map

package/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/create-program/useProvidedPrograms.d.ts

@@ -1,13 +0,0 @@
-import * as ts from 'typescript';
-import { Extra } from '../parser-options';
-import { ASTAndProgram } from './shared';
-declare function useProvidedPrograms(programInstances: Iterable<ts.Program>, extra: Extra): ASTAndProgram | 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/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/getModifiers.d.ts

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

package/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/index.d.ts

@@ -1,12 +0,0 @@
-export { AST, parse, parseAndGenerateServices, parseWithNodeMaps, ParseAndGenerateServicesResult, ParseWithNodeMapsResult, clearProgramCache, } from './parser';
-export { ParserServices, TSESTreeOptions } from './parser-options';
-export { simpleTraverse } from './simple-traverse';
-export * from './ts-estree';
-export { clearWatchCaches as clearCaches } from './create-program/createWatchProgram';
-export { createProgramFromConfigFile as createProgram } from './create-program/useProvidedPrograms';
-export * from './create-program/getScriptKind';
-export { typescriptVersionIsAtLeast } from './version-check';
-export * from './getModifiers';
-export { visitorKeys } from '@typescript-eslint/visitor-keys';
-export declare const version: string;
-//# sourceMappingURL=index.d.ts.map

package/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/jsx/xhtml-entities.d.ts

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

package/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/node-utils.d.ts

@@ -1,231 +0,0 @@
-import * as ts from 'typescript';
-import { TSESTree } from './ts-estree';
-import { AST_NODE_TYPES, AST_TOKEN_TYPES } from './ts-estree';
-declare const SyntaxKind: typeof ts.SyntaxKind;
-interface TokenToText extends TSESTree.PunctuatorTokenToText {
-    [SyntaxKind.ImportKeyword]: 'import';
-    [SyntaxKind.InKeyword]: 'in';
-    [SyntaxKind.InstanceOfKeyword]: 'instanceof';
-    [SyntaxKind.NewKeyword]: 'new';
-    [SyntaxKind.KeyOfKeyword]: 'keyof';
-    [SyntaxKind.ReadonlyKeyword]: 'readonly';
-    [SyntaxKind.UniqueKeyword]: 'unique';
-}
-/**
- * Returns true if the given ts.Token is the assignment operator
- * @param operator the operator token
- * @returns is assignment
- */
-export declare function isAssignmentOperator<T extends ts.SyntaxKind>(operator: ts.Token<T>): boolean;
-/**
- * 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<T extends ts.SyntaxKind>(operator: ts.Token<T>): boolean;
-/**
- * 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): T extends keyof TokenToText ? TokenToText[T] : string | undefined;
-/**
- * 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 true if the given ts.Node is a JSDoc comment
- * @param node the TypeScript node
- * @returns is JSDoc comment
- */
-export declare function isJSDocComment(node: ts.Node): node is ts.JSDoc;
-/**
- * Returns the binary expression type of the given ts.Token
- * @param operator the operator token
- * @returns the binary expression type
- */
-export declare function getBinaryExpressionType<T extends ts.SyntaxKind>(operator: ts.Token<T>): AST_NODE_TYPES.AssignmentExpression | AST_NODE_TYPES.LogicalExpression | AST_NODE_TYPES.BinaryExpression;
-/**
- * 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 start start data
- * @param end   end data
- * @param ast   the AST object
- * @returns the loc data
- */
-export declare function getLocFor(start: number, end: number, 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.SourceFile | ts.Block | ts.ModuleBlock | ts.ClassStaticBlockDeclaration): 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: ts.Node, ast: ts.SourceFile): [
-    number,
-    number
-];
-/**
- * Returns true if a given ts.Node is a token
- * @param node the ts.Node
- * @returns is a token
- */
-export declare function isToken(node: ts.Node): node is ts.Token<ts.TokenSyntaxKind>;
-/**
- * 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): 'let' | 'const' | '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): 'public' | 'protected' | 'private' | null;
-/**
- * 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.PropertyAccessExpression | ts.ElementAccessExpression | ts.CallExpression | ts.NonNullExpression, 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.Line | AST_TOKEN_TYPES.Block>;
-/**
- * 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 index: number;
-    readonly lineNumber: number;
-    readonly column: number;
-    constructor(message: string, fileName: string, index: number, lineNumber: number, column: number);
-}
-/**
- * @param ast     the AST object
- * @param start   the index at which the error starts
- * @param message the error message
- * @returns converted error object
- */
-export declare function createError(ast: ts.SourceFile, start: number, message: string): TSError;
-/**
- * @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 {};
-//# sourceMappingURL=node-utils.d.ts.map