@sprucelabs/spruce-cli 19.1.0 → 19.1.1

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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,3 @@
+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' | 'es2019.intl' | '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

@@ -0,0 +1,40 @@
+import { Program } from 'typescript';
+import { Lib } from './lib';
+type DebugLevel = boolean | ('typescript-eslint' | 'eslint' | 'typescript')[];
+type CacheDurationSeconds = number | 'Infinity';
+type EcmaVersion = 3 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 2015 | 2016 | 2017 | 2018 | 2019 | 2020 | 2021 | 2022;
+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[] | true;
+    projectFolderIgnoreList?: (string | RegExp)[];
+    range?: boolean;
+    sourceType?: SourceType;
+    tokens?: boolean;
+    tsconfigRootDir?: string;
+    warnOnUnsupportedTypeScriptVersion?: boolean;
+    moduleResolver?: string;
+    cacheLifetime?: {
+        glob?: CacheDurationSeconds;
+    };
+    [additionalProperties: string]: unknown;
+}
+export { CacheDurationSeconds, DebugLevel, EcmaVersion, ParserOptions, SourceType, };
+//# sourceMappingURL=parser-options.d.ts.map

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

@@ -0,0 +1,9 @@
+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/types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/types",
-  "version": "5.52.0",
+  "version": "5.54.1",
   "description": "Types for the TypeScript-ESTree AST spec",
   "keywords": [
     "eslint",
@@ -80,5 +80,5 @@
   "devDependencies": {
     "typescript": "*"
   },
-  "gitHead": "c46c793a34f82914a54b624adb57dfd4ac493633"
+  "gitHead": "a2494122fb326cae02d91f3fc1ad37de15039d8e"
 }

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

@@ -0,0 +1,9 @@
+import { SourceFile } from 'typescript';
+import { ASTMaps } from './convert';
+import { ParseSettings } from './parseSettings';
+import { 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/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/clear-caches.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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/node_modules/@typescript-eslint/typescript-estree/_ts3.4/dist/convert-comments.d.ts

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,159 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,9 @@
+import { ParseSettings } from '../parseSettings';
+import { ASTAndProgram } 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
+ */
+declare function createDefaultProgram(parseSettings: ParseSettings): ASTAndProgram | undefined;
+export { createDefaultProgram };
+//# sourceMappingURL=createDefaultProgram.d.ts.map

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

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

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

@@ -0,0 +1,9 @@
+import { ParseSettings } from '../parseSettings';
+import { ASTAndProgram } 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): ASTAndProgram | undefined;
+export { createProjectProgram };
+//# sourceMappingURL=createProjectProgram.d.ts.map

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

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

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

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

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

@@ -0,0 +1,5 @@
+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/getWatchProgramsForProjects.d.ts

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

@@ -0,0 +1,29 @@
+import { Program } from 'typescript';
+import * as ts from 'typescript';
+import { ModuleResolver } from '../parser-options';
+import { ParseSettings } from '../parseSettings';
+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(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): ASTAndProgram | undefined;
+declare function getModuleResolver(moduleResolverPath: string): ModuleResolver;
+/**
+ * Hash content for compare content.
+ * @param content hashed contend
+ * @returns hashed result
+ */
+declare function createHash(content: string): string;
+export { ASTAndProgram, CORE_COMPILER_OPTIONS, canonicalDirname, CanonicalPath, createDefaultCompilerOptionsFromExtra, createHash, ensureAbsolutePath, getCanonicalFileName, getAstFromProgram, getModuleResolver, };
+//# sourceMappingURL=shared.d.ts.map

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

@@ -0,0 +1,13 @@
+import * as ts from 'typescript';
+import { ParseSettings } from '../parseSettings';
+import { ASTAndProgram } from './shared';
+declare function useProvidedPrograms(programInstances: Iterable<ts.Program>, parseSettings: ParseSettings): 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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,12 @@
+export { AST, parse, parseAndGenerateServices, parseWithNodeMaps, ParseAndGenerateServicesResult, ParseWithNodeMapsResult, } from './parser';
+export { ParserServices, 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 { typescriptVersionIsAtLeast } from './version-check';
+export * from './getModifiers';
+export * from './clear-caches';
+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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,231 @@
+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