import { ESLint } from "eslint"; import * as ts from "typescript"; import { Program as Program$1, SyntaxKind } from "typescript"; //#region node_modules/@typescript-eslint/types/dist/generated/ast-spec.d.ts declare type Accessibility = 'private' | 'protected' | 'public'; declare type AccessorProperty = AccessorPropertyComputedName | AccessorPropertyNonComputedName; declare interface AccessorPropertyComputedName extends PropertyDefinitionComputedNameBase { type: AST_NODE_TYPES.AccessorProperty; } declare interface AccessorPropertyNonComputedName extends PropertyDefinitionNonComputedNameBase { type: AST_NODE_TYPES.AccessorProperty; } declare interface ArrayExpression extends BaseNode { type: AST_NODE_TYPES.ArrayExpression; /** * an element will be `null` in the case of a sparse array: `[1, ,3]` */ elements: (Expression | SpreadElement | null)[]; } declare interface ArrayPattern extends BaseNode { type: AST_NODE_TYPES.ArrayPattern; decorators: Decorator[]; elements: (DestructuringPattern | null)[]; optional: boolean; typeAnnotation: TSTypeAnnotation | undefined; } declare interface ArrowFunctionExpression extends BaseNode { type: AST_NODE_TYPES.ArrowFunctionExpression; async: boolean; body: BlockStatement | Expression; expression: boolean; generator: false; id: null; params: Parameter[]; returnType: TSTypeAnnotation | undefined; typeParameters: TSTypeParameterDeclaration | undefined; } declare interface AssignmentExpression extends BaseNode { type: AST_NODE_TYPES.AssignmentExpression; left: Expression; operator: ValueOf; right: Expression; } declare interface AssignmentOperatorToText { [SyntaxKind.AmpersandAmpersandEqualsToken]: '&&='; [SyntaxKind.AmpersandEqualsToken]: '&='; [SyntaxKind.AsteriskAsteriskEqualsToken]: '**='; [SyntaxKind.AsteriskEqualsToken]: '*='; [SyntaxKind.BarBarEqualsToken]: '||='; [SyntaxKind.BarEqualsToken]: '|='; [SyntaxKind.CaretEqualsToken]: '^='; [SyntaxKind.EqualsToken]: '='; [SyntaxKind.GreaterThanGreaterThanEqualsToken]: '>>='; [SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken]: '>>>='; [SyntaxKind.LessThanLessThanEqualsToken]: '<<='; [SyntaxKind.MinusEqualsToken]: '-='; [SyntaxKind.PercentEqualsToken]: '%='; [SyntaxKind.PlusEqualsToken]: '+='; [SyntaxKind.QuestionQuestionEqualsToken]: '??='; [SyntaxKind.SlashEqualsToken]: '/='; } declare interface AssignmentPattern extends BaseNode { type: AST_NODE_TYPES.AssignmentPattern; decorators: Decorator[]; left: BindingName; optional: boolean; right: Expression; typeAnnotation: TSTypeAnnotation | undefined; } declare enum AST_NODE_TYPES { AccessorProperty = "AccessorProperty", ArrayExpression = "ArrayExpression", ArrayPattern = "ArrayPattern", ArrowFunctionExpression = "ArrowFunctionExpression", AssignmentExpression = "AssignmentExpression", AssignmentPattern = "AssignmentPattern", AwaitExpression = "AwaitExpression", BinaryExpression = "BinaryExpression", BlockStatement = "BlockStatement", BreakStatement = "BreakStatement", CallExpression = "CallExpression", CatchClause = "CatchClause", ChainExpression = "ChainExpression", ClassBody = "ClassBody", ClassDeclaration = "ClassDeclaration", ClassExpression = "ClassExpression", ConditionalExpression = "ConditionalExpression", ContinueStatement = "ContinueStatement", DebuggerStatement = "DebuggerStatement", Decorator = "Decorator", DoWhileStatement = "DoWhileStatement", EmptyStatement = "EmptyStatement", ExportAllDeclaration = "ExportAllDeclaration", ExportDefaultDeclaration = "ExportDefaultDeclaration", ExportNamedDeclaration = "ExportNamedDeclaration", ExportSpecifier = "ExportSpecifier", ExpressionStatement = "ExpressionStatement", ForInStatement = "ForInStatement", ForOfStatement = "ForOfStatement", ForStatement = "ForStatement", FunctionDeclaration = "FunctionDeclaration", FunctionExpression = "FunctionExpression", Identifier = "Identifier", IfStatement = "IfStatement", ImportAttribute = "ImportAttribute", ImportDeclaration = "ImportDeclaration", ImportDefaultSpecifier = "ImportDefaultSpecifier", ImportExpression = "ImportExpression", ImportNamespaceSpecifier = "ImportNamespaceSpecifier", ImportSpecifier = "ImportSpecifier", JSXAttribute = "JSXAttribute", JSXClosingElement = "JSXClosingElement", JSXClosingFragment = "JSXClosingFragment", JSXElement = "JSXElement", JSXEmptyExpression = "JSXEmptyExpression", JSXExpressionContainer = "JSXExpressionContainer", JSXFragment = "JSXFragment", JSXIdentifier = "JSXIdentifier", JSXMemberExpression = "JSXMemberExpression", JSXNamespacedName = "JSXNamespacedName", JSXOpeningElement = "JSXOpeningElement", JSXOpeningFragment = "JSXOpeningFragment", JSXSpreadAttribute = "JSXSpreadAttribute", JSXSpreadChild = "JSXSpreadChild", JSXText = "JSXText", LabeledStatement = "LabeledStatement", Literal = "Literal", LogicalExpression = "LogicalExpression", MemberExpression = "MemberExpression", MetaProperty = "MetaProperty", MethodDefinition = "MethodDefinition", NewExpression = "NewExpression", ObjectExpression = "ObjectExpression", ObjectPattern = "ObjectPattern", PrivateIdentifier = "PrivateIdentifier", Program = "Program", Property = "Property", PropertyDefinition = "PropertyDefinition", RestElement = "RestElement", ReturnStatement = "ReturnStatement", SequenceExpression = "SequenceExpression", SpreadElement = "SpreadElement", StaticBlock = "StaticBlock", Super = "Super", SwitchCase = "SwitchCase", SwitchStatement = "SwitchStatement", TaggedTemplateExpression = "TaggedTemplateExpression", TemplateElement = "TemplateElement", TemplateLiteral = "TemplateLiteral", ThisExpression = "ThisExpression", ThrowStatement = "ThrowStatement", TryStatement = "TryStatement", UnaryExpression = "UnaryExpression", UpdateExpression = "UpdateExpression", VariableDeclaration = "VariableDeclaration", VariableDeclarator = "VariableDeclarator", WhileStatement = "WhileStatement", WithStatement = "WithStatement", YieldExpression = "YieldExpression", TSAbstractAccessorProperty = "TSAbstractAccessorProperty", TSAbstractKeyword = "TSAbstractKeyword", TSAbstractMethodDefinition = "TSAbstractMethodDefinition", TSAbstractPropertyDefinition = "TSAbstractPropertyDefinition", TSAnyKeyword = "TSAnyKeyword", TSArrayType = "TSArrayType", TSAsExpression = "TSAsExpression", TSAsyncKeyword = "TSAsyncKeyword", TSBigIntKeyword = "TSBigIntKeyword", TSBooleanKeyword = "TSBooleanKeyword", TSCallSignatureDeclaration = "TSCallSignatureDeclaration", TSClassImplements = "TSClassImplements", TSConditionalType = "TSConditionalType", TSConstructorType = "TSConstructorType", TSConstructSignatureDeclaration = "TSConstructSignatureDeclaration", TSDeclareFunction = "TSDeclareFunction", TSDeclareKeyword = "TSDeclareKeyword", TSEmptyBodyFunctionExpression = "TSEmptyBodyFunctionExpression", TSEnumBody = "TSEnumBody", TSEnumDeclaration = "TSEnumDeclaration", TSEnumMember = "TSEnumMember", TSExportAssignment = "TSExportAssignment", TSExportKeyword = "TSExportKeyword", TSExternalModuleReference = "TSExternalModuleReference", TSFunctionType = "TSFunctionType", TSImportEqualsDeclaration = "TSImportEqualsDeclaration", TSImportType = "TSImportType", TSIndexedAccessType = "TSIndexedAccessType", TSIndexSignature = "TSIndexSignature", TSInferType = "TSInferType", TSInstantiationExpression = "TSInstantiationExpression", TSInterfaceBody = "TSInterfaceBody", TSInterfaceDeclaration = "TSInterfaceDeclaration", TSInterfaceHeritage = "TSInterfaceHeritage", TSIntersectionType = "TSIntersectionType", TSIntrinsicKeyword = "TSIntrinsicKeyword", TSLiteralType = "TSLiteralType", TSMappedType = "TSMappedType", TSMethodSignature = "TSMethodSignature", TSModuleBlock = "TSModuleBlock", TSModuleDeclaration = "TSModuleDeclaration", TSNamedTupleMember = "TSNamedTupleMember", TSNamespaceExportDeclaration = "TSNamespaceExportDeclaration", TSNeverKeyword = "TSNeverKeyword", TSNonNullExpression = "TSNonNullExpression", TSNullKeyword = "TSNullKeyword", TSNumberKeyword = "TSNumberKeyword", TSObjectKeyword = "TSObjectKeyword", TSOptionalType = "TSOptionalType", TSParameterProperty = "TSParameterProperty", TSPrivateKeyword = "TSPrivateKeyword", TSPropertySignature = "TSPropertySignature", TSProtectedKeyword = "TSProtectedKeyword", TSPublicKeyword = "TSPublicKeyword", TSQualifiedName = "TSQualifiedName", TSReadonlyKeyword = "TSReadonlyKeyword", TSRestType = "TSRestType", TSSatisfiesExpression = "TSSatisfiesExpression", TSStaticKeyword = "TSStaticKeyword", TSStringKeyword = "TSStringKeyword", TSSymbolKeyword = "TSSymbolKeyword", TSTemplateLiteralType = "TSTemplateLiteralType", TSThisType = "TSThisType", TSTupleType = "TSTupleType", TSTypeAliasDeclaration = "TSTypeAliasDeclaration", TSTypeAnnotation = "TSTypeAnnotation", TSTypeAssertion = "TSTypeAssertion", TSTypeLiteral = "TSTypeLiteral", TSTypeOperator = "TSTypeOperator", TSTypeParameter = "TSTypeParameter", TSTypeParameterDeclaration = "TSTypeParameterDeclaration", TSTypeParameterInstantiation = "TSTypeParameterInstantiation", TSTypePredicate = "TSTypePredicate", TSTypeQuery = "TSTypeQuery", TSTypeReference = "TSTypeReference", TSUndefinedKeyword = "TSUndefinedKeyword", TSUnionType = "TSUnionType", TSUnknownKeyword = "TSUnknownKeyword", TSVoidKeyword = "TSVoidKeyword" } declare enum AST_TOKEN_TYPES { Boolean = "Boolean", Identifier = "Identifier", JSXIdentifier = "JSXIdentifier", PrivateIdentifier = "PrivateIdentifier", JSXText = "JSXText", Keyword = "Keyword", Null = "Null", Numeric = "Numeric", Punctuator = "Punctuator", RegularExpression = "RegularExpression", String = "String", Template = "Template", Block = "Block", Line = "Line" } declare interface AwaitExpression extends BaseNode { type: AST_NODE_TYPES.AwaitExpression; argument: Expression; } declare interface BaseNode extends NodeOrTokenData { type: AST_NODE_TYPES; } declare interface BaseToken extends NodeOrTokenData { type: AST_TOKEN_TYPES; value: string; } declare interface BigIntLiteral extends LiteralBase { bigint: string; value: bigint | null; } declare type BinaryExpression = PrivateInExpression | SymmetricBinaryExpression; declare interface BinaryOperatorToText { [SyntaxKind.AmpersandAmpersandToken]: '&&'; [SyntaxKind.AmpersandToken]: '&'; [SyntaxKind.AsteriskAsteriskToken]: '**'; [SyntaxKind.AsteriskToken]: '*'; [SyntaxKind.BarBarToken]: '||'; [SyntaxKind.BarToken]: '|'; [SyntaxKind.CaretToken]: '^'; [SyntaxKind.EqualsEqualsEqualsToken]: '==='; [SyntaxKind.EqualsEqualsToken]: '=='; [SyntaxKind.ExclamationEqualsEqualsToken]: '!=='; [SyntaxKind.ExclamationEqualsToken]: '!='; [SyntaxKind.GreaterThanEqualsToken]: '>='; [SyntaxKind.GreaterThanGreaterThanGreaterThanToken]: '>>>'; [SyntaxKind.GreaterThanGreaterThanToken]: '>>'; [SyntaxKind.GreaterThanToken]: '>'; [SyntaxKind.InKeyword]: 'in'; [SyntaxKind.InstanceOfKeyword]: 'instanceof'; [SyntaxKind.LessThanEqualsToken]: '<='; [SyntaxKind.LessThanLessThanToken]: '<<'; [SyntaxKind.LessThanToken]: '<'; [SyntaxKind.MinusToken]: '-'; [SyntaxKind.PercentToken]: '%'; [SyntaxKind.PlusToken]: '+'; [SyntaxKind.SlashToken]: '/'; } declare type BindingName = BindingPattern | Identifier; declare type BindingPattern = ArrayPattern | ObjectPattern; declare interface BlockComment extends BaseToken { type: AST_TOKEN_TYPES.Block; } declare interface BlockStatement extends BaseNode { type: AST_NODE_TYPES.BlockStatement; body: Statement[]; } declare interface BooleanLiteral extends LiteralBase { raw: 'false' | 'true'; value: boolean; } declare interface BooleanToken extends BaseToken { type: AST_TOKEN_TYPES.Boolean; } declare interface BreakStatement extends BaseNode { type: AST_NODE_TYPES.BreakStatement; label: Identifier | null; } declare interface CallExpression extends BaseNode { type: AST_NODE_TYPES.CallExpression; arguments: CallExpressionArgument[]; callee: Expression; optional: boolean; typeArguments: TSTypeParameterInstantiation | undefined; } declare type CallExpressionArgument = Expression | SpreadElement; declare interface CatchClause extends BaseNode { type: AST_NODE_TYPES.CatchClause; body: BlockStatement; param: BindingName | null; } declare type ChainElement = CallExpression | MemberExpression | TSNonNullExpression; declare interface ChainExpression extends BaseNode { type: AST_NODE_TYPES.ChainExpression; expression: ChainElement; } declare interface ClassBase extends BaseNode { /** * Whether the class is an abstract class. * @example * ```ts * abstract class Foo {} * ``` */ abstract: boolean; /** * The class body. */ body: ClassBody; /** * Whether the class has been `declare`d: * @example * ```ts * declare class Foo {} * ``` */ declare: boolean; /** * The decorators declared for the class. * @example * ```ts * @deco * class Foo {} * ``` */ decorators: Decorator[]; /** * The class's name. * - For a `ClassExpression` this may be `null` if the name is omitted. * - For a `ClassDeclaration` this may be `null` if and only if the parent is * an `ExportDefaultDeclaration`. */ id: Identifier | null; /** * The implemented interfaces for the class. */ implements: TSClassImplements[]; /** * The super class this class extends. */ superClass: LeftHandSideExpression | null; /** * The generic type parameters passed to the superClass. */ superTypeArguments: TSTypeParameterInstantiation | undefined; /** * The generic type parameters declared for the class. */ typeParameters: TSTypeParameterDeclaration | undefined; } declare interface ClassBody extends BaseNode { type: AST_NODE_TYPES.ClassBody; body: ClassElement[]; } declare type ClassDeclaration = ClassDeclarationWithName | ClassDeclarationWithOptionalName; declare interface ClassDeclarationBase extends ClassBase { type: AST_NODE_TYPES.ClassDeclaration; } /** * A normal class declaration: * ``` * class A {} * ``` */ declare interface ClassDeclarationWithName extends ClassDeclarationBase { id: Identifier; } /** * Default-exported class declarations have optional names: * ``` * export default class {} * ``` */ declare interface ClassDeclarationWithOptionalName extends ClassDeclarationBase { id: Identifier | null; } declare type ClassElement = AccessorProperty | MethodDefinition | PropertyDefinition | StaticBlock | TSAbstractAccessorProperty | TSAbstractMethodDefinition | TSAbstractPropertyDefinition | TSIndexSignature; declare interface ClassExpression extends ClassBase { type: AST_NODE_TYPES.ClassExpression; abstract: false; declare: false; } declare interface ClassMethodDefinitionNonComputedNameBase extends MethodDefinitionBase { computed: false; key: ClassPropertyNameNonComputed; } declare interface ClassPropertyDefinitionNonComputedNameBase extends PropertyDefinitionBase { computed: false; key: ClassPropertyNameNonComputed; } declare type ClassPropertyNameNonComputed = PrivateIdentifier | PropertyNameNonComputed; declare type Comment = BlockComment | LineComment; declare interface ConditionalExpression extends BaseNode { type: AST_NODE_TYPES.ConditionalExpression; alternate: Expression; consequent: Expression; test: Expression; } declare interface ConstDeclaration extends LetOrConstOrVarDeclarationBase { /** * In a `declare const` declaration, the declarators may have initializers, but * not definite assignment assertions. Each declarator cannot have both an * initializer and a type annotation. * * Even if the declaration has no `declare`, it may still be ambient and have * no initializer. */ declarations: VariableDeclaratorMaybeInit[]; kind: 'const'; } declare interface ContinueStatement extends BaseNode { type: AST_NODE_TYPES.ContinueStatement; label: Identifier | null; } declare interface DebuggerStatement extends BaseNode { type: AST_NODE_TYPES.DebuggerStatement; } declare interface Decorator extends BaseNode { type: AST_NODE_TYPES.Decorator; expression: LeftHandSideExpression; } declare type DefaultExportDeclarations = ClassDeclarationWithOptionalName | Expression | FunctionDeclarationWithName | FunctionDeclarationWithOptionalName | TSDeclareFunction | TSEnumDeclaration | TSInterfaceDeclaration | TSModuleDeclaration | TSTypeAliasDeclaration | VariableDeclaration; declare type DestructuringPattern = ArrayPattern | AssignmentPattern | Identifier | MemberExpression | ObjectPattern | RestElement; declare interface DoWhileStatement extends BaseNode { type: AST_NODE_TYPES.DoWhileStatement; body: Statement; test: Expression; } declare interface EmptyStatement extends BaseNode { type: AST_NODE_TYPES.EmptyStatement; } declare type EntityName = Identifier | ThisExpression | TSQualifiedName; declare interface ExportAllDeclaration extends BaseNode { type: AST_NODE_TYPES.ExportAllDeclaration; /** * The assertions declared for the export. * @example * ```ts * export * from 'mod' assert \{ type: 'json' \}; * ``` * @deprecated Replaced with {@link `attributes`}. */ assertions: ImportAttribute[]; /** * The attributes declared for the export. * @example * ```ts * export * from 'mod' with \{ type: 'json' \}; * ``` */ attributes: ImportAttribute[]; /** * The name for the exported items (`as X`). `null` if no name is assigned. */ exported: Identifier | null; /** * The kind of the export. */ exportKind: ExportKind; /** * The source module being exported from. */ source: StringLiteral; } declare type ExportAndImportKind = 'type' | 'value'; declare interface ExportDefaultDeclaration extends BaseNode { type: AST_NODE_TYPES.ExportDefaultDeclaration; /** * The declaration being exported. */ declaration: DefaultExportDeclarations; /** * The kind of the export. Always `value` for default exports. */ exportKind: 'value'; } declare type ExportKind = ExportAndImportKind; declare type ExportNamedDeclaration = ExportNamedDeclarationWithoutSourceWithMultiple | ExportNamedDeclarationWithoutSourceWithSingle | ExportNamedDeclarationWithSource; declare interface ExportNamedDeclarationBase extends BaseNode { type: AST_NODE_TYPES.ExportNamedDeclaration; /** * The assertions declared for the export. * @example * ```ts * export { foo } from 'mod' assert \{ type: 'json' \}; * ``` * This will be an empty array if `source` is `null` * @deprecated Replaced with {@link `attributes`}. */ assertions: ImportAttribute[]; /** * The attributes declared for the export. * @example * ```ts * export { foo } from 'mod' with \{ type: 'json' \}; * ``` * This will be an empty array if `source` is `null` */ attributes: ImportAttribute[]; /** * The exported declaration. * @example * ```ts * export const x = 1; * ``` * This will be `null` if `source` is not `null`, or if there are `specifiers` */ declaration: NamedExportDeclarations | null; /** * The kind of the export. */ exportKind: ExportKind; /** * The source module being exported from. */ source: StringLiteral | null; /** * The specifiers being exported. * @example * ```ts * export { a, b }; * ``` * This will be an empty array if `declaration` is not `null` */ specifiers: ExportSpecifier[]; } /** * Exporting names from the current module. * ``` * export {}; * export { a, b }; * ``` */ declare interface ExportNamedDeclarationWithoutSourceWithMultiple extends ExportNamedDeclarationBase { /** * This will always be an empty array. * @deprecated Replaced with {@link `attributes`}. */ assertions: ImportAttribute[]; /** * This will always be an empty array. */ attributes: ImportAttribute[]; declaration: null; source: null; specifiers: ExportSpecifierWithIdentifierLocal[]; } /** * Exporting a single named declaration. * ``` * export const x = 1; * ``` */ declare interface ExportNamedDeclarationWithoutSourceWithSingle extends ExportNamedDeclarationBase { /** * This will always be an empty array. * @deprecated Replaced with {@link `attributes`}. */ assertions: ImportAttribute[]; /** * This will always be an empty array. */ attributes: ImportAttribute[]; declaration: NamedExportDeclarations; source: null; /** * This will always be an empty array. */ specifiers: ExportSpecifierWithIdentifierLocal[]; } /** * Export names from another module. * ``` * export { a, b } from 'mod'; * ``` */ declare interface ExportNamedDeclarationWithSource extends ExportNamedDeclarationBase { declaration: null; source: StringLiteral; } declare type ExportSpecifier = ExportSpecifierWithIdentifierLocal | ExportSpecifierWithStringOrLiteralLocal; declare interface ExportSpecifierBase extends BaseNode { type: AST_NODE_TYPES.ExportSpecifier; exported: Identifier | StringLiteral; exportKind: ExportKind; local: Identifier | StringLiteral; } declare interface ExportSpecifierWithIdentifierLocal extends ExportSpecifierBase { local: Identifier; } declare interface ExportSpecifierWithStringOrLiteralLocal extends ExportSpecifierBase { local: Identifier | StringLiteral; } declare type Expression = ArrayExpression | ArrayPattern | ArrowFunctionExpression | AssignmentExpression | AwaitExpression | BinaryExpression | CallExpression | ChainExpression | ClassExpression | ConditionalExpression | FunctionExpression | Identifier | ImportExpression | JSXElement | JSXFragment | LiteralExpression | LogicalExpression | MemberExpression | MetaProperty | NewExpression | ObjectExpression | ObjectPattern | SequenceExpression | Super | TaggedTemplateExpression | TemplateLiteral | ThisExpression | TSAsExpression | TSInstantiationExpression | TSNonNullExpression | TSSatisfiesExpression | TSTypeAssertion | UnaryExpression | UpdateExpression | YieldExpression; declare interface ExpressionStatement extends BaseNode { type: AST_NODE_TYPES.ExpressionStatement; directive: string | undefined; expression: Expression; } declare type ForInitialiser = Expression | LetOrConstOrVarDeclaration; declare interface ForInStatement extends BaseNode { type: AST_NODE_TYPES.ForInStatement; body: Statement; left: ForInitialiser; right: Expression; } declare type ForOfInitialiser = Expression | LetOrConstOrVarDeclaration | UsingInForOfDeclaration; declare interface ForOfStatement extends BaseNode { type: AST_NODE_TYPES.ForOfStatement; await: boolean; body: Statement; left: ForOfInitialiser; right: Expression; } declare interface ForStatement extends BaseNode { type: AST_NODE_TYPES.ForStatement; body: Statement; init: Expression | ForInitialiser | null; test: Expression | null; update: Expression | null; } declare interface FunctionBase extends BaseNode { /** * Whether the function is async: * ``` * async function foo() {} * const x = async function () {} * const x = async () => {} * ``` */ async: boolean; /** * The body of the function. * - For an `ArrowFunctionExpression` this may be an `Expression` or `BlockStatement`. * - For a `FunctionDeclaration` or `FunctionExpression` this is always a `BlockStatement`. * - For a `TSDeclareFunction` this is always `undefined`. * - For a `TSEmptyBodyFunctionExpression` this is always `null`. */ body: BlockStatement | Expression | null | undefined; /** * This is only `true` if and only if the node is a `TSDeclareFunction` and it has `declare`: * ``` * declare function foo() {} * ``` */ declare: boolean; /** * This is only ever `true` if and only the node is an `ArrowFunctionExpression` and the body * is an expression: * ``` * (() => 1) * ``` */ expression: boolean; /** * Whether the function is a generator function: * ``` * function *foo() {} * const x = function *() {} * ``` * This is always `false` for arrow functions as they cannot be generators. */ generator: boolean; /** * The function's name. * - For an `ArrowFunctionExpression` this is always `null`. * - For a `FunctionExpression` this may be `null` if the name is omitted. * - For a `FunctionDeclaration` or `TSDeclareFunction` this may be `null` if * and only if the parent is an `ExportDefaultDeclaration`. */ id: Identifier | null; /** * The list of parameters declared for the function. */ params: Parameter[]; /** * The return type annotation for the function. */ returnType: TSTypeAnnotation | undefined; /** * The generic type parameter declaration for the function. */ typeParameters: TSTypeParameterDeclaration | undefined; } declare type FunctionDeclaration = FunctionDeclarationWithName | FunctionDeclarationWithOptionalName; declare interface FunctionDeclarationBase extends FunctionBase { type: AST_NODE_TYPES.FunctionDeclaration; body: BlockStatement; declare: false; expression: false; } /** * A normal function declaration: * ``` * function f() {} * ``` */ declare interface FunctionDeclarationWithName extends FunctionDeclarationBase { id: Identifier; } /** * Default-exported function declarations have optional names: * ``` * export default function () {} * ``` */ declare interface FunctionDeclarationWithOptionalName extends FunctionDeclarationBase { id: Identifier | null; } declare interface FunctionExpression extends FunctionBase { type: AST_NODE_TYPES.FunctionExpression; body: BlockStatement; expression: false; } declare type FunctionLike = ArrowFunctionExpression | FunctionDeclaration | FunctionExpression | TSDeclareFunction | TSEmptyBodyFunctionExpression; declare interface Identifier extends BaseNode { type: AST_NODE_TYPES.Identifier; decorators: Decorator[]; name: string; optional: boolean; typeAnnotation: TSTypeAnnotation | undefined; } declare interface IdentifierToken extends BaseToken { type: AST_TOKEN_TYPES.Identifier; } declare interface IfStatement extends BaseNode { type: AST_NODE_TYPES.IfStatement; alternate: Statement | null; consequent: Statement; test: Expression; } declare interface ImportAttribute extends BaseNode { type: AST_NODE_TYPES.ImportAttribute; key: Identifier | Literal; value: Literal; } declare type ImportClause = ImportDefaultSpecifier | ImportNamespaceSpecifier | ImportSpecifier; declare interface ImportDeclaration extends BaseNode { type: AST_NODE_TYPES.ImportDeclaration; /** * The assertions declared for the export. * @example * ```ts * import * from 'mod' assert \{ type: 'json' \}; * ``` * @deprecated Replaced with {@link `attributes`}. */ assertions: ImportAttribute[]; /** * The attributes declared for the export. * @example * ```ts * import * from 'mod' with \{ type: 'json' \}; * ``` */ attributes: ImportAttribute[]; /** * The kind of the import. */ importKind: ImportKind; /** * The source module being imported from. */ source: StringLiteral; /** * The specifiers being imported. * If this is an empty array then either there are no specifiers: * ``` * import {} from 'mod'; * ``` * Or it is a side-effect import: * ``` * import 'mod'; * ``` */ specifiers: ImportClause[]; } declare interface ImportDefaultSpecifier extends BaseNode { type: AST_NODE_TYPES.ImportDefaultSpecifier; local: Identifier; } declare interface ImportExpression extends BaseNode { type: AST_NODE_TYPES.ImportExpression; /** * The attributes declared for the dynamic import. * @example * ```ts * import('mod', \{ assert: \{ type: 'json' \} \}); * ``` * @deprecated Replaced with {@link `options`}. */ attributes: Expression | null; /** * The options bag declared for the dynamic import. * @example * ```ts * import('mod', \{ assert: \{ type: 'json' \} \}); * ``` */ options: Expression | null; source: Expression; } declare type ImportKind = ExportAndImportKind; declare interface ImportNamespaceSpecifier extends BaseNode { type: AST_NODE_TYPES.ImportNamespaceSpecifier; local: Identifier; } declare interface ImportSpecifier extends BaseNode { type: AST_NODE_TYPES.ImportSpecifier; imported: Identifier | StringLiteral; importKind: ImportKind; local: Identifier; } declare interface JSXAttribute extends BaseNode { type: AST_NODE_TYPES.JSXAttribute; name: JSXIdentifier | JSXNamespacedName; value: JSXElement | JSXExpression | Literal | null; } declare type JSXChild = JSXElement | JSXExpression | JSXFragment | JSXText; declare interface JSXClosingElement extends BaseNode { type: AST_NODE_TYPES.JSXClosingElement; name: JSXTagNameExpression; } declare interface JSXClosingFragment extends BaseNode { type: AST_NODE_TYPES.JSXClosingFragment; } declare interface JSXElement extends BaseNode { type: AST_NODE_TYPES.JSXElement; children: JSXChild[]; closingElement: JSXClosingElement | null; openingElement: JSXOpeningElement; } declare interface JSXEmptyExpression extends BaseNode { type: AST_NODE_TYPES.JSXEmptyExpression; } declare type JSXExpression = JSXExpressionContainer | JSXSpreadChild; declare interface JSXExpressionContainer extends BaseNode { type: AST_NODE_TYPES.JSXExpressionContainer; expression: Expression | JSXEmptyExpression; } declare interface JSXFragment extends BaseNode { type: AST_NODE_TYPES.JSXFragment; children: JSXChild[]; closingFragment: JSXClosingFragment; openingFragment: JSXOpeningFragment; } declare interface JSXIdentifier extends BaseNode { type: AST_NODE_TYPES.JSXIdentifier; name: string; } declare interface JSXIdentifierToken extends BaseToken { type: AST_TOKEN_TYPES.JSXIdentifier; } declare interface JSXMemberExpression extends BaseNode { type: AST_NODE_TYPES.JSXMemberExpression; object: JSXTagNameExpression; property: JSXIdentifier; } declare interface JSXNamespacedName extends BaseNode { type: AST_NODE_TYPES.JSXNamespacedName; name: JSXIdentifier; namespace: JSXIdentifier; } declare interface JSXOpeningElement extends BaseNode { type: AST_NODE_TYPES.JSXOpeningElement; attributes: (JSXAttribute | JSXSpreadAttribute)[]; name: JSXTagNameExpression; selfClosing: boolean; typeArguments: TSTypeParameterInstantiation | undefined; } declare interface JSXOpeningFragment extends BaseNode { type: AST_NODE_TYPES.JSXOpeningFragment; } declare interface JSXSpreadAttribute extends BaseNode { type: AST_NODE_TYPES.JSXSpreadAttribute; argument: Expression; } declare interface JSXSpreadChild extends BaseNode { type: AST_NODE_TYPES.JSXSpreadChild; expression: Expression | JSXEmptyExpression; } declare type JSXTagNameExpression = JSXIdentifier | JSXMemberExpression | JSXNamespacedName; declare interface JSXText extends BaseNode { type: AST_NODE_TYPES.JSXText; raw: string; value: string; } declare interface JSXTextToken extends BaseToken { type: AST_TOKEN_TYPES.JSXText; } declare interface KeywordToken extends BaseToken { type: AST_TOKEN_TYPES.Keyword; } declare interface LabeledStatement extends BaseNode { type: AST_NODE_TYPES.LabeledStatement; body: Statement; label: Identifier; } declare type LeftHandSideExpression = ArrayExpression | ArrayPattern | ArrowFunctionExpression | CallExpression | ClassExpression | FunctionExpression | Identifier | JSXElement | JSXFragment | LiteralExpression | MemberExpression | MetaProperty | ObjectExpression | ObjectPattern | SequenceExpression | Super | TaggedTemplateExpression | ThisExpression | TSAsExpression | TSNonNullExpression | TSTypeAssertion; declare type LetOrConstOrVarDeclaration = ConstDeclaration | LetOrVarDeclaredDeclaration | LetOrVarNonDeclaredDeclaration; declare interface LetOrConstOrVarDeclarationBase extends BaseNode { type: AST_NODE_TYPES.VariableDeclaration; /** * The variables declared by this declaration. * Always non-empty. * @example * ```ts * let x; * let y, z; * ``` */ declarations: LetOrConstOrVarDeclarator[]; /** * Whether the declaration is `declare`d * @example * ```ts * declare const x = 1; * ``` */ declare: boolean; /** * The keyword used to declare the variable(s) * @example * ```ts * const x = 1; * let y = 2; * var z = 3; * ``` */ kind: 'const' | 'let' | 'var'; } declare type LetOrConstOrVarDeclarator = VariableDeclaratorDefiniteAssignment | VariableDeclaratorMaybeInit | VariableDeclaratorNoInit; declare interface LetOrVarDeclaredDeclaration extends LetOrConstOrVarDeclarationBase { /** * In a `declare let` declaration, the declarators must not have definite assignment * assertions or initializers. * * @example * ```ts * using x = 1; * using y =1, z = 2; * ``` */ declarations: VariableDeclaratorNoInit[]; declare: true; kind: 'let' | 'var'; } declare interface LetOrVarNonDeclaredDeclaration extends LetOrConstOrVarDeclarationBase { /** * In a `let`/`var` declaration, the declarators may have definite assignment * assertions or initializers, but not both. */ declarations: (VariableDeclaratorDefiniteAssignment | VariableDeclaratorMaybeInit)[]; declare: false; kind: 'let' | 'var'; } declare interface LineComment extends BaseToken { type: AST_TOKEN_TYPES.Line; } declare type Literal = BigIntLiteral | BooleanLiteral | NullLiteral | NumberLiteral | RegExpLiteral | StringLiteral; declare interface LiteralBase extends BaseNode { type: AST_NODE_TYPES.Literal; raw: string; value: bigint | boolean | number | string | RegExp | null; } declare type LiteralExpression = Literal | TemplateLiteral; declare interface LogicalExpression extends BaseNode { type: AST_NODE_TYPES.LogicalExpression; left: Expression; operator: '&&' | '??' | '||'; right: Expression; } declare type MemberExpression = MemberExpressionComputedName | MemberExpressionNonComputedName; declare interface MemberExpressionBase extends BaseNode { computed: boolean; object: Expression; optional: boolean; property: Expression | Identifier | PrivateIdentifier; } declare interface MemberExpressionComputedName extends MemberExpressionBase { type: AST_NODE_TYPES.MemberExpression; computed: true; property: Expression; } declare interface MemberExpressionNonComputedName extends MemberExpressionBase { type: AST_NODE_TYPES.MemberExpression; computed: false; property: Identifier | PrivateIdentifier; } declare interface MetaProperty extends BaseNode { type: AST_NODE_TYPES.MetaProperty; meta: Identifier; property: Identifier; } declare type MethodDefinition = MethodDefinitionComputedName | MethodDefinitionNonComputedName; /** this should not be directly used - instead use MethodDefinitionComputedNameBase or MethodDefinitionNonComputedNameBase */ declare interface MethodDefinitionBase extends BaseNode { accessibility: Accessibility | undefined; computed: boolean; decorators: Decorator[]; key: PropertyName; kind: 'constructor' | 'get' | 'method' | 'set'; optional: boolean; override: boolean; static: boolean; value: FunctionExpression | TSEmptyBodyFunctionExpression; } declare interface MethodDefinitionComputedName extends MethodDefinitionComputedNameBase { type: AST_NODE_TYPES.MethodDefinition; } declare interface MethodDefinitionComputedNameBase extends MethodDefinitionBase { computed: true; key: PropertyNameComputed; } declare interface MethodDefinitionNonComputedName extends ClassMethodDefinitionNonComputedNameBase { type: AST_NODE_TYPES.MethodDefinition; } declare interface MethodDefinitionNonComputedNameBase extends MethodDefinitionBase { computed: false; key: PropertyNameNonComputed; } declare type NamedExportDeclarations = ClassDeclarationWithName | ClassDeclarationWithOptionalName | FunctionDeclarationWithName | FunctionDeclarationWithOptionalName | TSDeclareFunction | TSEnumDeclaration | TSImportEqualsDeclaration | TSInterfaceDeclaration | TSModuleDeclaration | TSTypeAliasDeclaration | VariableDeclaration; declare interface NewExpression extends BaseNode { type: AST_NODE_TYPES.NewExpression; arguments: CallExpressionArgument[]; callee: Expression; typeArguments: TSTypeParameterInstantiation | undefined; } declare type Node = AccessorProperty | ArrayExpression | ArrayPattern | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BlockStatement | BreakStatement | CallExpression | CatchClause | ChainExpression | ClassBody | ClassDeclaration | ClassExpression | ConditionalExpression | ContinueStatement | DebuggerStatement | Decorator | DoWhileStatement | EmptyStatement | ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ExportSpecifier | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | FunctionDeclaration | FunctionExpression | Identifier | IfStatement | ImportAttribute | ImportDeclaration | ImportDefaultSpecifier | ImportExpression | ImportNamespaceSpecifier | ImportSpecifier | JSXAttribute | JSXClosingElement | JSXClosingFragment | JSXElement | JSXEmptyExpression | JSXExpressionContainer | JSXFragment | JSXIdentifier | JSXMemberExpression | JSXNamespacedName | JSXOpeningElement | JSXOpeningFragment | JSXSpreadAttribute | JSXSpreadChild | JSXText | LabeledStatement | Literal | LogicalExpression | MemberExpression | MetaProperty | MethodDefinition | NewExpression | ObjectExpression | ObjectPattern | PrivateIdentifier | Program$2 | Property | PropertyDefinition | RestElement | ReturnStatement | SequenceExpression | SpreadElement | StaticBlock | Super | SwitchCase | SwitchStatement | TaggedTemplateExpression | TemplateElement | TemplateLiteral | ThisExpression | ThrowStatement | TryStatement | TSAbstractAccessorProperty | TSAbstractKeyword | TSAbstractMethodDefinition | TSAbstractPropertyDefinition | TSAnyKeyword | TSArrayType | TSAsExpression | TSAsyncKeyword | TSBigIntKeyword | TSBooleanKeyword | TSCallSignatureDeclaration | TSClassImplements | TSConditionalType | TSConstructorType | TSConstructSignatureDeclaration | TSDeclareFunction | TSDeclareKeyword | TSEmptyBodyFunctionExpression | TSEnumBody | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSExportKeyword | TSExternalModuleReference | TSFunctionType | TSImportEqualsDeclaration | TSImportType | TSIndexedAccessType | TSIndexSignature | TSInferType | TSInstantiationExpression | TSInterfaceBody | TSInterfaceDeclaration | TSInterfaceHeritage | TSIntersectionType | TSIntrinsicKeyword | TSLiteralType | TSMappedType | TSMethodSignature | TSModuleBlock | TSModuleDeclaration | TSNamedTupleMember | TSNamespaceExportDeclaration | TSNeverKeyword | TSNonNullExpression | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSOptionalType | TSParameterProperty | TSPrivateKeyword | TSPropertySignature | TSProtectedKeyword | TSPublicKeyword | TSQualifiedName | TSReadonlyKeyword | TSRestType | TSSatisfiesExpression | TSStaticKeyword | TSStringKeyword | TSSymbolKeyword | TSTemplateLiteralType | TSThisType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeLiteral | TSTypeOperator | TSTypeParameter | TSTypeParameterDeclaration | TSTypeParameterInstantiation | TSTypePredicate | TSTypeQuery | TSTypeReference | TSUndefinedKeyword | TSUnionType | TSUnknownKeyword | TSVoidKeyword | UnaryExpression | UpdateExpression | VariableDeclaration | VariableDeclarator | WhileStatement | WithStatement | YieldExpression; declare interface NodeOrTokenData { type: string; /** * The source location information of the node. * * The loc property is defined as nullable by ESTree, but ESLint requires this property. */ loc: SourceLocation; range: Range; } declare interface NullLiteral extends LiteralBase { raw: 'null'; value: null; } declare interface NullToken extends BaseToken { type: AST_TOKEN_TYPES.Null; } declare interface NumberLiteral extends LiteralBase { value: number; } declare interface NumericToken extends BaseToken { type: AST_TOKEN_TYPES.Numeric; } declare interface ObjectExpression extends BaseNode { type: AST_NODE_TYPES.ObjectExpression; properties: ObjectLiteralElement[]; } declare type ObjectLiteralElement = Property | SpreadElement; declare interface ObjectPattern extends BaseNode { type: AST_NODE_TYPES.ObjectPattern; decorators: Decorator[]; optional: boolean; properties: (Property | RestElement)[]; typeAnnotation: TSTypeAnnotation | undefined; } declare type Parameter = ArrayPattern | AssignmentPattern | Identifier | ObjectPattern | RestElement | TSParameterProperty; declare type ParameterPropertyParameter = (AssignmentPattern & { left: Identifier; }) | Identifier; declare interface Position { /** * Column number on the line (0-indexed) */ column: number; /** * Line number (1-indexed) */ line: number; } declare interface PrivateIdentifier extends BaseNode { type: AST_NODE_TYPES.PrivateIdentifier; name: string; } declare interface PrivateIdentifierToken extends BaseToken { type: AST_TOKEN_TYPES.PrivateIdentifier; } declare interface PrivateInExpression extends BaseNode { type: AST_NODE_TYPES.BinaryExpression; left: PrivateIdentifier; operator: 'in'; right: Expression; } declare interface Program$2 extends NodeOrTokenData { type: AST_NODE_TYPES.Program; body: ProgramStatement[]; comments: Comment[] | undefined; sourceType: 'module' | 'script'; tokens: Token[] | undefined; } declare type ProgramStatement = ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ImportDeclaration | Statement | TSImportEqualsDeclaration | TSNamespaceExportDeclaration; declare type Property = PropertyComputedName | PropertyNonComputedName; declare interface PropertyBase extends BaseNode { type: AST_NODE_TYPES.Property; computed: boolean; key: PropertyName; kind: 'get' | 'init' | 'set'; method: boolean; optional: boolean; shorthand: boolean; value: AssignmentPattern | BindingName | Expression | TSEmptyBodyFunctionExpression; } declare interface PropertyComputedName extends PropertyBase { computed: true; key: PropertyNameComputed; } declare type PropertyDefinition = PropertyDefinitionComputedName | PropertyDefinitionNonComputedName; declare interface PropertyDefinitionBase extends BaseNode { accessibility: Accessibility | undefined; computed: boolean; declare: boolean; decorators: Decorator[]; definite: boolean; key: PropertyName; optional: boolean; override: boolean; readonly: boolean; static: boolean; typeAnnotation: TSTypeAnnotation | undefined; value: Expression | null; } declare interface PropertyDefinitionComputedName extends PropertyDefinitionComputedNameBase { type: AST_NODE_TYPES.PropertyDefinition; } declare interface PropertyDefinitionComputedNameBase extends PropertyDefinitionBase { computed: true; key: PropertyNameComputed; } declare interface PropertyDefinitionNonComputedName extends ClassPropertyDefinitionNonComputedNameBase { type: AST_NODE_TYPES.PropertyDefinition; } declare interface PropertyDefinitionNonComputedNameBase extends PropertyDefinitionBase { computed: false; key: PropertyNameNonComputed; } declare type PropertyName = ClassPropertyNameNonComputed | PropertyNameComputed | PropertyNameNonComputed; declare type PropertyNameComputed = Expression; declare type PropertyNameNonComputed = Identifier | NumberLiteral | StringLiteral; declare interface PropertyNonComputedName extends PropertyBase { computed: false; key: PropertyNameNonComputed; } declare interface PunctuatorToken extends BaseToken { type: AST_TOKEN_TYPES.Punctuator; value: ValueOf; } declare interface PunctuatorTokenToText extends AssignmentOperatorToText { [SyntaxKind.AmpersandAmpersandToken]: '&&'; [SyntaxKind.AmpersandToken]: '&'; [SyntaxKind.AsteriskAsteriskToken]: '**'; [SyntaxKind.AsteriskToken]: '*'; [SyntaxKind.AtToken]: '@'; [SyntaxKind.BacktickToken]: '`'; [SyntaxKind.BarBarToken]: '||'; [SyntaxKind.BarToken]: '|'; [SyntaxKind.CaretToken]: '^'; [SyntaxKind.CloseBraceToken]: '}'; [SyntaxKind.CloseBracketToken]: ']'; [SyntaxKind.CloseParenToken]: ')'; [SyntaxKind.ColonToken]: ':'; [SyntaxKind.CommaToken]: ','; [SyntaxKind.DotDotDotToken]: '...'; [SyntaxKind.DotToken]: '.'; [SyntaxKind.EqualsEqualsEqualsToken]: '==='; [SyntaxKind.EqualsEqualsToken]: '=='; [SyntaxKind.EqualsGreaterThanToken]: '=>'; [SyntaxKind.ExclamationEqualsEqualsToken]: '!=='; [SyntaxKind.ExclamationEqualsToken]: '!='; [SyntaxKind.ExclamationToken]: '!'; [SyntaxKind.GreaterThanEqualsToken]: '>='; [SyntaxKind.GreaterThanGreaterThanGreaterThanToken]: '>>>'; [SyntaxKind.GreaterThanGreaterThanToken]: '>>'; [SyntaxKind.GreaterThanToken]: '>'; [SyntaxKind.HashToken]: '#'; [SyntaxKind.LessThanEqualsToken]: '<='; [SyntaxKind.LessThanLessThanToken]: '<<'; [SyntaxKind.LessThanSlashToken]: '; right: Expression; } declare interface TaggedTemplateExpression extends BaseNode { type: AST_NODE_TYPES.TaggedTemplateExpression; quasi: TemplateLiteral; tag: Expression; typeArguments: TSTypeParameterInstantiation | undefined; } declare interface TemplateElement extends BaseNode { type: AST_NODE_TYPES.TemplateElement; tail: boolean; value: { cooked: string | null; raw: string; }; } declare interface TemplateLiteral extends BaseNode { type: AST_NODE_TYPES.TemplateLiteral; expressions: Expression[]; quasis: TemplateElement[]; } declare interface TemplateToken extends BaseToken { type: AST_TOKEN_TYPES.Template; } declare interface ThisExpression extends BaseNode { type: AST_NODE_TYPES.ThisExpression; } declare interface ThrowStatement extends BaseNode { type: AST_NODE_TYPES.ThrowStatement; argument: Expression; } declare type Token = BooleanToken | Comment | IdentifierToken | JSXIdentifierToken | JSXTextToken | KeywordToken | NullToken | NumericToken | PrivateIdentifierToken | PunctuatorToken | RegularExpressionToken | StringToken | TemplateToken; declare interface TryStatement extends BaseNode { type: AST_NODE_TYPES.TryStatement; block: BlockStatement; finalizer: BlockStatement | null; handler: CatchClause | null; } declare type TSAbstractAccessorProperty = TSAbstractAccessorPropertyComputedName | TSAbstractAccessorPropertyNonComputedName; declare interface TSAbstractAccessorPropertyComputedName extends PropertyDefinitionComputedNameBase { type: AST_NODE_TYPES.TSAbstractAccessorProperty; value: null; } declare interface TSAbstractAccessorPropertyNonComputedName extends PropertyDefinitionNonComputedNameBase { type: AST_NODE_TYPES.TSAbstractAccessorProperty; value: null; } declare interface TSAbstractKeyword extends BaseNode { type: AST_NODE_TYPES.TSAbstractKeyword; } declare type TSAbstractMethodDefinition = TSAbstractMethodDefinitionComputedName | TSAbstractMethodDefinitionNonComputedName; declare interface TSAbstractMethodDefinitionComputedName extends MethodDefinitionComputedNameBase { type: AST_NODE_TYPES.TSAbstractMethodDefinition; } declare interface TSAbstractMethodDefinitionNonComputedName extends MethodDefinitionNonComputedNameBase { type: AST_NODE_TYPES.TSAbstractMethodDefinition; } declare type TSAbstractPropertyDefinition = TSAbstractPropertyDefinitionComputedName | TSAbstractPropertyDefinitionNonComputedName; declare interface TSAbstractPropertyDefinitionComputedName extends PropertyDefinitionComputedNameBase { type: AST_NODE_TYPES.TSAbstractPropertyDefinition; value: null; } declare interface TSAbstractPropertyDefinitionNonComputedName extends PropertyDefinitionNonComputedNameBase { type: AST_NODE_TYPES.TSAbstractPropertyDefinition; value: null; } declare interface TSAnyKeyword extends BaseNode { type: AST_NODE_TYPES.TSAnyKeyword; } declare interface TSArrayType extends BaseNode { type: AST_NODE_TYPES.TSArrayType; elementType: TypeNode; } declare interface TSAsExpression extends BaseNode { type: AST_NODE_TYPES.TSAsExpression; expression: Expression; typeAnnotation: TypeNode; } declare interface TSAsyncKeyword extends BaseNode { type: AST_NODE_TYPES.TSAsyncKeyword; } declare interface TSBigIntKeyword extends BaseNode { type: AST_NODE_TYPES.TSBigIntKeyword; } declare interface TSBooleanKeyword extends BaseNode { type: AST_NODE_TYPES.TSBooleanKeyword; } declare interface TSCallSignatureDeclaration extends TSFunctionSignatureBase { type: AST_NODE_TYPES.TSCallSignatureDeclaration; } declare interface TSClassImplements extends TSHeritageBase { type: AST_NODE_TYPES.TSClassImplements; } declare interface TSConditionalType extends BaseNode { type: AST_NODE_TYPES.TSConditionalType; checkType: TypeNode; extendsType: TypeNode; falseType: TypeNode; trueType: TypeNode; } declare interface TSConstructorType extends TSFunctionSignatureBase { type: AST_NODE_TYPES.TSConstructorType; abstract: boolean; } declare interface TSConstructSignatureDeclaration extends TSFunctionSignatureBase { type: AST_NODE_TYPES.TSConstructSignatureDeclaration; } declare type TSDeclareFunction = TSDeclareFunctionNoDeclare | TSDeclareFunctionWithDeclare; declare interface TSDeclareFunctionBase extends FunctionBase { type: AST_NODE_TYPES.TSDeclareFunction; /** * TS1183: An implementation cannot be declared in ambient contexts. */ body: undefined; /** * Whether the declaration has `declare` modifier. */ declare: boolean; expression: false; } /** * Function declaration without the `declare` keyword: * ``` * function foo(): void; * ``` * This can either be an overload signature or a declaration in an ambient context * (e.g. `declare module`) */ declare interface TSDeclareFunctionNoDeclare extends TSDeclareFunctionBase { declare: false; /** * - TS1221: Generators are not allowed in an ambient context. * - TS1222: An overload signature cannot be declared as a generator. */ generator: false; } /** * Function declaration with the `declare` keyword: * ``` * declare function foo(): void; * ``` */ declare interface TSDeclareFunctionWithDeclare extends TSDeclareFunctionBase { /** * TS1040: 'async' modifier cannot be used in an ambient context. */ async: false; declare: true; /** * TS1221: Generators are not allowed in an ambient context. */ generator: false; } declare interface TSDeclareKeyword extends BaseNode { type: AST_NODE_TYPES.TSDeclareKeyword; } declare interface TSEmptyBodyFunctionExpression extends FunctionBase { type: AST_NODE_TYPES.TSEmptyBodyFunctionExpression; body: null; id: null; } declare interface TSEnumBody extends BaseNode { type: AST_NODE_TYPES.TSEnumBody; members: TSEnumMember[]; } declare interface TSEnumDeclaration extends BaseNode { type: AST_NODE_TYPES.TSEnumDeclaration; /** * The body of the enum. */ body: TSEnumBody; /** * Whether this is a `const` enum. * @example * ```ts * const enum Foo {} * ``` */ const: boolean; /** * Whether this is a `declare`d enum. * @example * ```ts * declare enum Foo {} * ``` */ declare: boolean; /** * The enum name. */ id: Identifier; /** * The enum members. * @deprecated Use {@link body} instead. */ members: TSEnumMember[]; } declare interface TSEnumMember extends BaseNode { type: AST_NODE_TYPES.TSEnumMember; id: Identifier | StringLiteral; initializer: Expression | undefined; /** * @deprecated the enum member is always non-computed. */ computed: boolean; } declare interface TSExportAssignment extends BaseNode { type: AST_NODE_TYPES.TSExportAssignment; expression: Expression; } declare interface TSExportKeyword extends BaseNode { type: AST_NODE_TYPES.TSExportKeyword; } declare interface TSExternalModuleReference extends BaseNode { type: AST_NODE_TYPES.TSExternalModuleReference; expression: StringLiteral; } declare interface TSFunctionSignatureBase extends BaseNode { params: Parameter[]; returnType: TSTypeAnnotation | undefined; typeParameters: TSTypeParameterDeclaration | undefined; } declare interface TSFunctionType extends TSFunctionSignatureBase { type: AST_NODE_TYPES.TSFunctionType; } declare interface TSHeritageBase extends BaseNode { expression: Expression; typeArguments: TSTypeParameterInstantiation | undefined; } declare type TSImportEqualsDeclaration = TSImportEqualsNamespaceDeclaration | TSImportEqualsRequireDeclaration; declare interface TSImportEqualsDeclarationBase extends BaseNode { type: AST_NODE_TYPES.TSImportEqualsDeclaration; /** * The locally imported name. */ id: Identifier; /** * The kind of the import. Always `'value'` unless `moduleReference` is a * `TSExternalModuleReference`. */ importKind: ImportKind; /** * The value being aliased. * @example * ```ts * import F1 = A; * import F2 = A.B.C; * import F3 = require('mod'); * ``` */ moduleReference: Identifier | TSExternalModuleReference | TSQualifiedName; } declare interface TSImportEqualsNamespaceDeclaration extends TSImportEqualsDeclarationBase { /** * The kind of the import. */ importKind: 'value'; /** * The value being aliased. * ``` * import F1 = A; * import F2 = A.B.C; * ``` */ moduleReference: Identifier | TSQualifiedName; } declare interface TSImportEqualsRequireDeclaration extends TSImportEqualsDeclarationBase { /** * The kind of the import. */ importKind: ImportKind; /** * The value being aliased. * ``` * import F3 = require('mod'); * ``` */ moduleReference: TSExternalModuleReference; } declare interface TSImportType extends BaseNode { type: AST_NODE_TYPES.TSImportType; /** @deprecated Use {@link `source`} instead. */ argument: TypeNode; options: ObjectExpression | null; qualifier: EntityName | null; source: StringLiteral; typeArguments: TSTypeParameterInstantiation | null; } declare interface TSIndexedAccessType extends BaseNode { type: AST_NODE_TYPES.TSIndexedAccessType; indexType: TypeNode; objectType: TypeNode; } declare interface TSIndexSignature extends BaseNode { type: AST_NODE_TYPES.TSIndexSignature; accessibility: Accessibility | undefined; parameters: Parameter[]; readonly: boolean; static: boolean; typeAnnotation: TSTypeAnnotation | undefined; } declare interface TSInferType extends BaseNode { type: AST_NODE_TYPES.TSInferType; typeParameter: TSTypeParameter; } declare interface TSInstantiationExpression extends BaseNode { type: AST_NODE_TYPES.TSInstantiationExpression; expression: Expression; typeArguments: TSTypeParameterInstantiation; } declare interface TSInterfaceBody extends BaseNode { type: AST_NODE_TYPES.TSInterfaceBody; body: TypeElement[]; } declare interface TSInterfaceDeclaration extends BaseNode { type: AST_NODE_TYPES.TSInterfaceDeclaration; /** * The body of the interface */ body: TSInterfaceBody; /** * Whether the interface was `declare`d */ declare: boolean; /** * The types this interface `extends` */ extends: TSInterfaceHeritage[]; /** * The name of this interface */ id: Identifier; /** * The generic type parameters declared for the interface. Empty declaration * (`<>`) is different from no declaration. */ typeParameters: TSTypeParameterDeclaration | undefined; } declare interface TSInterfaceHeritage extends TSHeritageBase { type: AST_NODE_TYPES.TSInterfaceHeritage; } declare interface TSIntersectionType extends BaseNode { type: AST_NODE_TYPES.TSIntersectionType; types: TypeNode[]; } declare interface TSIntrinsicKeyword extends BaseNode { type: AST_NODE_TYPES.TSIntrinsicKeyword; } declare interface TSLiteralType extends BaseNode { type: AST_NODE_TYPES.TSLiteralType; literal: Exclude | UnaryExpressionMinus | UnaryExpressionPlus; } declare interface TSMappedType extends BaseNode { type: AST_NODE_TYPES.TSMappedType; constraint: TypeNode; key: Identifier; nameType: TypeNode | null; optional: boolean | '+' | '-' | undefined; readonly: boolean | '+' | '-' | undefined; typeAnnotation: TypeNode | undefined; /** @deprecated Use {@link `constraint`} and {@link `key`} instead. */ typeParameter: TSTypeParameter; } declare type TSMethodSignature = TSMethodSignatureComputedName | TSMethodSignatureNonComputedName; declare interface TSMethodSignatureBase extends BaseNode { type: AST_NODE_TYPES.TSMethodSignature; accessibility: Accessibility | undefined; computed: boolean; key: PropertyName; kind: 'get' | 'method' | 'set'; optional: boolean; params: Parameter[]; readonly: boolean; returnType: TSTypeAnnotation | undefined; static: boolean; typeParameters: TSTypeParameterDeclaration | undefined; } declare interface TSMethodSignatureComputedName extends TSMethodSignatureBase { computed: true; key: PropertyNameComputed; } declare interface TSMethodSignatureNonComputedName extends TSMethodSignatureBase { computed: false; key: PropertyNameNonComputed; } declare interface TSModuleBlock extends BaseNode { type: AST_NODE_TYPES.TSModuleBlock; body: ProgramStatement[]; } declare type TSModuleDeclaration = TSModuleDeclarationGlobal | TSModuleDeclarationModule | TSModuleDeclarationNamespace; declare interface TSModuleDeclarationBase extends BaseNode { type: AST_NODE_TYPES.TSModuleDeclaration; /** * The body of the module. * This can only be `undefined` for the code `declare module 'mod';` */ body?: TSModuleBlock; /** * Whether the module is `declare`d * @example * ```ts * declare namespace F {} * ``` */ declare: boolean; /** * Whether this is a global declaration * @example * ```ts * declare global {} * ``` * * @deprecated Use {@link kind} instead */ global: boolean; /** * The name of the module * ``` * namespace A {} * namespace A.B.C {} * module 'a' {} * ``` */ id: Identifier | Literal | TSQualifiedName; /** * The keyword used to define this module declaration * @example * ```ts * namespace Foo {} * ^^^^^^^^^ * * module 'foo' {} * ^^^^^^ * * global {} * ^^^^^^ * ``` */ kind: TSModuleDeclarationKind; } declare interface TSModuleDeclarationGlobal extends TSModuleDeclarationBase { body: TSModuleBlock; /** * This will always be an Identifier with name `global` */ id: Identifier; kind: 'global'; } declare type TSModuleDeclarationKind = 'global' | 'module' | 'namespace'; declare type TSModuleDeclarationModule = TSModuleDeclarationModuleWithIdentifierId | TSModuleDeclarationModuleWithStringId; declare interface TSModuleDeclarationModuleBase extends TSModuleDeclarationBase { kind: 'module'; } /** * The legacy module declaration, replaced with namespace declarations. * ``` * module A {} * ``` */ declare interface TSModuleDeclarationModuleWithIdentifierId extends TSModuleDeclarationModuleBase { body: TSModuleBlock; id: Identifier; kind: 'module'; } declare type TSModuleDeclarationModuleWithStringId = TSModuleDeclarationModuleWithStringIdDeclared | TSModuleDeclarationModuleWithStringIdNotDeclared; /** * A string module declaration that is declared: * ``` * declare module 'foo' {} * declare module 'foo'; * ``` */ declare interface TSModuleDeclarationModuleWithStringIdDeclared extends TSModuleDeclarationModuleBase { body?: TSModuleBlock; declare: true; id: StringLiteral; kind: 'module'; } /** * A string module declaration that is not declared: * ``` * module 'foo' {} * ``` */ declare interface TSModuleDeclarationModuleWithStringIdNotDeclared extends TSModuleDeclarationModuleBase { body: TSModuleBlock; declare: false; id: StringLiteral; kind: 'module'; } declare interface TSModuleDeclarationNamespace extends TSModuleDeclarationBase { body: TSModuleBlock; id: Identifier | TSQualifiedName; kind: 'namespace'; } declare interface TSNamedTupleMember extends BaseNode { type: AST_NODE_TYPES.TSNamedTupleMember; elementType: TypeNode; label: Identifier; optional: boolean; } /** * For the following declaration: * ``` * export as namespace X; * ``` */ declare interface TSNamespaceExportDeclaration extends BaseNode { type: AST_NODE_TYPES.TSNamespaceExportDeclaration; /** * The name of the global variable that's exported as namespace */ id: Identifier; } declare interface TSNeverKeyword extends BaseNode { type: AST_NODE_TYPES.TSNeverKeyword; } declare interface TSNonNullExpression extends BaseNode { type: AST_NODE_TYPES.TSNonNullExpression; expression: Expression; } declare interface TSNullKeyword extends BaseNode { type: AST_NODE_TYPES.TSNullKeyword; } declare interface TSNumberKeyword extends BaseNode { type: AST_NODE_TYPES.TSNumberKeyword; } declare interface TSObjectKeyword extends BaseNode { type: AST_NODE_TYPES.TSObjectKeyword; } declare interface TSOptionalType extends BaseNode { type: AST_NODE_TYPES.TSOptionalType; typeAnnotation: TypeNode; } declare interface TSParameterProperty extends BaseNode { type: AST_NODE_TYPES.TSParameterProperty; accessibility: Accessibility | undefined; decorators: Decorator[]; override: boolean; parameter: ParameterPropertyParameter; readonly: boolean; static: boolean; } declare interface TSPrivateKeyword extends BaseNode { type: AST_NODE_TYPES.TSPrivateKeyword; } declare type TSPropertySignature = TSPropertySignatureComputedName | TSPropertySignatureNonComputedName; declare interface TSPropertySignatureBase extends BaseNode { type: AST_NODE_TYPES.TSPropertySignature; accessibility: Accessibility | undefined; computed: boolean; key: PropertyName; optional: boolean; readonly: boolean; static: boolean; typeAnnotation: TSTypeAnnotation | undefined; } declare interface TSPropertySignatureComputedName extends TSPropertySignatureBase { computed: true; key: PropertyNameComputed; } declare interface TSPropertySignatureNonComputedName extends TSPropertySignatureBase { computed: false; key: PropertyNameNonComputed; } declare interface TSProtectedKeyword extends BaseNode { type: AST_NODE_TYPES.TSProtectedKeyword; } declare interface TSPublicKeyword extends BaseNode { type: AST_NODE_TYPES.TSPublicKeyword; } declare interface TSQualifiedName extends BaseNode { type: AST_NODE_TYPES.TSQualifiedName; left: EntityName; right: Identifier; } declare interface TSReadonlyKeyword extends BaseNode { type: AST_NODE_TYPES.TSReadonlyKeyword; } declare interface TSRestType extends BaseNode { type: AST_NODE_TYPES.TSRestType; typeAnnotation: TypeNode; } declare interface TSSatisfiesExpression extends BaseNode { type: AST_NODE_TYPES.TSSatisfiesExpression; expression: Expression; typeAnnotation: TypeNode; } declare interface TSStaticKeyword extends BaseNode { type: AST_NODE_TYPES.TSStaticKeyword; } declare interface TSStringKeyword extends BaseNode { type: AST_NODE_TYPES.TSStringKeyword; } declare interface TSSymbolKeyword extends BaseNode { type: AST_NODE_TYPES.TSSymbolKeyword; } declare interface TSTemplateLiteralType extends BaseNode { type: AST_NODE_TYPES.TSTemplateLiteralType; quasis: TemplateElement[]; types: TypeNode[]; } declare interface TSThisType extends BaseNode { type: AST_NODE_TYPES.TSThisType; } declare interface TSTupleType extends BaseNode { type: AST_NODE_TYPES.TSTupleType; elementTypes: TypeNode[]; } declare interface TSTypeAliasDeclaration extends BaseNode { type: AST_NODE_TYPES.TSTypeAliasDeclaration; /** * Whether the type was `declare`d. * @example * ```ts * declare type T = 1; * ``` */ declare: boolean; /** * The name of the type. */ id: Identifier; /** * The "value" (type) of the declaration */ typeAnnotation: TypeNode; /** * The generic type parameters declared for the type. Empty declaration * (`<>`) is different from no declaration. */ typeParameters: TSTypeParameterDeclaration | undefined; } declare interface TSTypeAnnotation extends BaseNode { type: AST_NODE_TYPES.TSTypeAnnotation; typeAnnotation: TypeNode; } declare interface TSTypeAssertion extends BaseNode { type: AST_NODE_TYPES.TSTypeAssertion; expression: Expression; typeAnnotation: TypeNode; } declare interface TSTypeLiteral extends BaseNode { type: AST_NODE_TYPES.TSTypeLiteral; members: TypeElement[]; } declare interface TSTypeOperator extends BaseNode { type: AST_NODE_TYPES.TSTypeOperator; operator: 'keyof' | 'readonly' | 'unique'; typeAnnotation: TypeNode | undefined; } declare interface TSTypeParameter extends BaseNode { type: AST_NODE_TYPES.TSTypeParameter; const: boolean; constraint: TypeNode | undefined; default: TypeNode | undefined; in: boolean; name: Identifier; out: boolean; } declare interface TSTypeParameterDeclaration extends BaseNode { type: AST_NODE_TYPES.TSTypeParameterDeclaration; params: TSTypeParameter[]; } declare interface TSTypeParameterInstantiation extends BaseNode { type: AST_NODE_TYPES.TSTypeParameterInstantiation; params: TypeNode[]; } declare interface TSTypePredicate extends BaseNode { type: AST_NODE_TYPES.TSTypePredicate; asserts: boolean; parameterName: Identifier | TSThisType; typeAnnotation: TSTypeAnnotation | null; } declare interface TSTypeQuery extends BaseNode { type: AST_NODE_TYPES.TSTypeQuery; exprName: EntityName | TSImportType; typeArguments: TSTypeParameterInstantiation | undefined; } declare interface TSTypeReference extends BaseNode { type: AST_NODE_TYPES.TSTypeReference; typeArguments: TSTypeParameterInstantiation | undefined; typeName: EntityName; } declare interface TSUndefinedKeyword extends BaseNode { type: AST_NODE_TYPES.TSUndefinedKeyword; } declare interface TSUnionType extends BaseNode { type: AST_NODE_TYPES.TSUnionType; types: TypeNode[]; } declare interface TSUnknownKeyword extends BaseNode { type: AST_NODE_TYPES.TSUnknownKeyword; } declare interface TSVoidKeyword extends BaseNode { type: AST_NODE_TYPES.TSVoidKeyword; } declare type TypeElement = TSCallSignatureDeclaration | TSConstructSignatureDeclaration | TSIndexSignature | TSMethodSignature | TSPropertySignature; declare type TypeNode = TSAbstractKeyword | TSAnyKeyword | TSArrayType | TSAsyncKeyword | TSBigIntKeyword | TSBooleanKeyword | TSConditionalType | TSConstructorType | TSDeclareKeyword | TSExportKeyword | TSFunctionType | TSImportType | TSIndexedAccessType | TSInferType | TSIntersectionType | TSIntrinsicKeyword | TSLiteralType | TSMappedType | TSNamedTupleMember | TSNeverKeyword | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSOptionalType | TSPrivateKeyword | TSProtectedKeyword | TSPublicKeyword | TSQualifiedName | TSReadonlyKeyword | TSRestType | TSStaticKeyword | TSStringKeyword | TSSymbolKeyword | TSTemplateLiteralType | TSThisType | TSTupleType | TSTypeLiteral | TSTypeOperator | TSTypePredicate | TSTypeQuery | TSTypeReference | TSUndefinedKeyword | TSUnionType | TSUnknownKeyword | TSVoidKeyword; declare type UnaryExpression = UnaryExpressionBitwiseNot | UnaryExpressionDelete | UnaryExpressionMinus | UnaryExpressionNot | UnaryExpressionPlus | UnaryExpressionTypeof | UnaryExpressionVoid; declare interface UnaryExpressionBase extends BaseNode { argument: Expression; operator: string; prefix: boolean; } declare type UnaryExpressionBitwiseNot = UnaryExpressionSpecific<'~'>; declare type UnaryExpressionDelete = UnaryExpressionSpecific<'delete'>; declare type UnaryExpressionMinus = UnaryExpressionSpecific<'-'>; declare type UnaryExpressionNot = UnaryExpressionSpecific<'!'>; declare type UnaryExpressionPlus = UnaryExpressionSpecific<'+'>; declare interface UnaryExpressionSpecific extends UnaryExpressionBase { type: AST_NODE_TYPES.UnaryExpression; operator: T; } declare type UnaryExpressionTypeof = UnaryExpressionSpecific<'typeof'>; declare type UnaryExpressionVoid = UnaryExpressionSpecific<'void'>; declare interface UpdateExpression extends UnaryExpressionBase { type: AST_NODE_TYPES.UpdateExpression; operator: '++' | '--'; } declare type UsingDeclaration = UsingInForOfDeclaration | UsingInNormalContextDeclaration; declare interface UsingDeclarationBase extends BaseNode { type: AST_NODE_TYPES.VariableDeclaration; /** * This value will always be `false` * because 'declare' modifier cannot appear on a 'using' declaration. */ declare: false; /** * The keyword used to declare the variable(s) * @example * ```ts * using x = 1; * await using y = 2; * ``` */ kind: 'await using' | 'using'; } declare type UsingDeclarator = UsingInForOfDeclarator | UsingInNormalContextDeclarator; declare interface UsingInForOfDeclaration extends UsingDeclarationBase { /** * The variables declared by this declaration. * Always has exactly one element. * @example * ```ts * for (using x of y) {} * ``` */ declarations: [UsingInForOfDeclarator]; } declare interface UsingInForOfDeclarator extends VariableDeclaratorBase { definite: false; id: Identifier; init: null; } declare interface UsingInNormalContextDeclaration extends UsingDeclarationBase { /** * The variables declared by this declaration. * Always non-empty. * @example * ```ts * using x = 1; * using y = 1, z = 2; * ``` */ declarations: UsingInNormalContextDeclarator[]; } declare interface UsingInNormalContextDeclarator extends VariableDeclaratorBase { definite: false; id: Identifier; init: Expression; } declare type ValueOf = T[keyof T]; declare type VariableDeclaration = LetOrConstOrVarDeclaration | UsingDeclaration; declare type VariableDeclarator = LetOrConstOrVarDeclarator | UsingDeclarator; declare interface VariableDeclaratorBase extends BaseNode { type: AST_NODE_TYPES.VariableDeclarator; /** * Whether there's definite assignment assertion (`let x!: number`). * If `true`, then: `id` must be an identifier with a type annotation, * `init` must be `null`, and the declarator must be a `var`/`let` declarator. */ definite: boolean; /** * The name(s) of the variable(s). */ id: BindingName; /** * The initializer expression of the variable. Must be present for `const` unless * in a `declare const`. */ init: Expression | null; } declare interface VariableDeclaratorDefiniteAssignment extends VariableDeclaratorBase { definite: true; /** * The name of the variable. Must have a type annotation. */ id: Identifier; init: null; } declare interface VariableDeclaratorMaybeInit extends VariableDeclaratorBase { definite: false; } declare interface VariableDeclaratorNoInit extends VariableDeclaratorBase { definite: false; init: null; } declare interface WhileStatement extends BaseNode { type: AST_NODE_TYPES.WhileStatement; body: Statement; test: Expression; } declare interface WithStatement extends BaseNode { type: AST_NODE_TYPES.WithStatement; body: Statement; object: Expression; } declare interface YieldExpression extends BaseNode { type: AST_NODE_TYPES.YieldExpression; argument: Expression | null; delegate: boolean; } //#endregion //#region node_modules/@typescript-eslint/types/dist/lib.d.ts type Lib = 'decorators' | 'decorators.legacy' | 'dom' | 'dom.asynciterable' | 'dom.iterable' | 'es5' | 'es6' | 'es7' | 'es2015' | 'es2015.collection' | 'es2015.core' | 'es2015.generator' | 'es2015.iterable' | 'es2015.promise' | 'es2015.proxy' | 'es2015.reflect' | 'es2015.symbol' | 'es2015.symbol.wellknown' | 'es2016' | 'es2016.array.include' | 'es2016.full' | 'es2016.intl' | 'es2017' | 'es2017.arraybuffer' | 'es2017.date' | 'es2017.full' | 'es2017.intl' | 'es2017.object' | 'es2017.sharedmemory' | 'es2017.string' | 'es2017.typedarrays' | 'es2018' | 'es2018.asyncgenerator' | 'es2018.asynciterable' | 'es2018.full' | 'es2018.intl' | 'es2018.promise' | 'es2018.regexp' | 'es2019' | 'es2019.array' | 'es2019.full' | 'es2019.intl' | 'es2019.object' | 'es2019.string' | 'es2019.symbol' | 'es2020' | 'es2020.bigint' | 'es2020.date' | 'es2020.full' | 'es2020.intl' | 'es2020.number' | 'es2020.promise' | 'es2020.sharedmemory' | 'es2020.string' | 'es2020.symbol.wellknown' | 'es2021' | 'es2021.full' | 'es2021.intl' | 'es2021.promise' | 'es2021.string' | 'es2021.weakref' | 'es2022' | 'es2022.array' | 'es2022.error' | 'es2022.full' | 'es2022.intl' | 'es2022.object' | 'es2022.regexp' | 'es2022.string' | 'es2023' | 'es2023.array' | 'es2023.collection' | 'es2023.full' | 'es2023.intl' | 'es2024' | 'es2024.arraybuffer' | 'es2024.collection' | 'es2024.full' | 'es2024.object' | 'es2024.promise' | 'es2024.regexp' | 'es2024.sharedmemory' | 'es2024.string' | 'es2025' | 'es2025.collection' | 'es2025.float16' | 'es2025.full' | 'es2025.intl' | 'es2025.iterator' | 'es2025.promise' | 'es2025.regexp' | 'esnext' | 'esnext.array' | 'esnext.asynciterable' | 'esnext.bigint' | 'esnext.collection' | 'esnext.date' | 'esnext.decorators' | 'esnext.disposable' | 'esnext.error' | 'esnext.float16' | 'esnext.full' | 'esnext.intl' | 'esnext.iterator' | 'esnext.object' | 'esnext.promise' | 'esnext.regexp' | 'esnext.sharedmemory' | 'esnext.string' | 'esnext.symbol' | 'esnext.temporal' | 'esnext.typedarrays' | 'esnext.weakref' | 'lib' | 'scripthost' | 'webworker' | 'webworker.asynciterable' | 'webworker.importscripts' | 'webworker.iterable'; //#endregion //#region node_modules/@typescript-eslint/types/dist/parser-options.d.ts type DebugLevel = boolean | ('eslint' | 'typescript' | 'typescript-eslint')[]; type CacheDurationSeconds = number | 'Infinity'; type EcmaVersion$1 = 3 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 2015 | 2016 | 2017 | 2018 | 2019 | 2020 | 2021 | 2022 | 2023 | 2024 | 2025 | 2026 | 'latest' | undefined; type SourceTypeClassic = 'module' | 'script'; type SourceType$1 = 'commonjs' | SourceTypeClassic; type JSDocParsingMode = 'all' | 'none' | 'type-info'; /** * Granular options to configure the project service. */ interface ProjectServiceOptions { /** * Globs of files to allow running with the default project compiler options * despite not being matched by the project service. */ allowDefaultProject?: string[]; /** * Path to a TSConfig to use instead of TypeScript's default project configuration. * @default 'tsconfig.json' */ defaultProject?: string; /** * Whether to allow TypeScript plugins as configured in the TSConfig. */ loadTypeScriptPlugins?: boolean; /** * The maximum number of files {@link allowDefaultProject} may match. * Each file match slows down linting, so if you do need to use this, please * file an informative issue on typescript-eslint explaining why - so we can * help you avoid using it! * @default 8 */ maximumDefaultProjectFileMatchCount_THIS_WILL_SLOW_DOWN_LINTING?: number; } interface ParserOptions$1 { [additionalProperties: string]: unknown; cacheLifetime?: { glob?: CacheDurationSeconds; }; debugLevel?: DebugLevel; ecmaFeatures?: { [key: string]: unknown; globalReturn?: boolean | undefined; jsx?: boolean | undefined; } | undefined; ecmaVersion?: EcmaVersion$1; emitDecoratorMetadata?: boolean; errorOnTypeScriptSyntacticAndSemanticIssues?: boolean; errorOnUnknownASTType?: boolean; experimentalDecorators?: boolean; extraFileExtensions?: string[]; filePath?: string; isolatedDeclarations?: boolean; jsDocParsingMode?: JSDocParsingMode; jsxFragmentName?: string | null; jsxPragma?: string | null; lib?: Lib[]; programs?: Program$1[] | null; project?: boolean | string | string[] | null; projectFolderIgnoreList?: string[]; projectService?: boolean | ProjectServiceOptions; range?: boolean; sourceType?: SourceType$1 | undefined; tokens?: boolean; tsconfigRootDir?: string; warnOnUnsupportedTypeScriptVersion?: boolean; } //#endregion //#region node_modules/@typescript-eslint/types/dist/ts-estree.d.ts declare module './generated/ast-spec' { interface BaseNode { parent: Node; } interface Program { /** * @remarks This never-used property exists only as a convenience for code that tries to access node parents repeatedly. */ parent?: never; } interface AccessorPropertyComputedName { parent: ClassBody; } interface AccessorPropertyNonComputedName { parent: ClassBody; } interface TSAbstractAccessorPropertyComputedName { parent: ClassBody; } interface TSAbstractAccessorPropertyNonComputedName { parent: ClassBody; } interface VariableDeclaratorDefiniteAssignment { parent: VariableDeclaration; } interface VariableDeclaratorMaybeInit { parent: VariableDeclaration; } interface VariableDeclaratorNoInit { parent: VariableDeclaration; } interface UsingInForOfDeclarator { parent: VariableDeclaration; } interface UsingInNormalContextDeclarator { parent: VariableDeclaration; } interface CatchClause { parent: TryStatement; } interface ClassBody { parent: ClassDeclaration | ClassExpression; } interface ImportAttribute { parent: ExportAllDeclaration | ExportNamedDeclaration | ImportDeclaration | TSImportType; } interface ImportDefaultSpecifier { parent: ImportDeclaration; } interface ImportNamespaceSpecifier { parent: ImportDeclaration; } interface ImportSpecifier { parent: ExportAllDeclaration | ExportNamedDeclaration | ImportDeclaration; } interface ExportDefaultDeclaration { parent: BlockStatement | Program$2 | TSModuleBlock; } interface ExportNamedDeclarationWithoutSourceWithMultiple { parent: BlockStatement | Program$2 | TSModuleBlock; } interface ExportNamedDeclarationWithoutSourceWithSingle { parent: BlockStatement | Program$2 | TSModuleBlock; } interface ExportNamedDeclarationWithSource { parent: BlockStatement | Program$2 | TSModuleBlock; } interface FunctionDeclarationWithName { parent: BlockStatement | ExportDefaultDeclaration | ExportNamedDeclaration | Program$2; } interface FunctionDeclarationWithOptionalName { parent: ExportDefaultDeclaration; } interface JSXAttribute { parent: JSXOpeningElement; } interface JSXClosingElement { parent: JSXElement; } interface JSXClosingFragment { parent: JSXFragment; } interface JSXOpeningElement { parent: JSXElement; } interface JSXOpeningFragment { parent: JSXFragment; } interface JSXSpreadAttribute { parent: JSXOpeningElement; } interface MethodDefinitionComputedName { parent: ClassBody; } interface MethodDefinitionNonComputedName { parent: ClassBody; } interface TSAbstractMethodDefinitionComputedName { parent: ClassBody; } interface TSAbstractMethodDefinitionNonComputedName { parent: ClassBody; } interface PropertyComputedName { parent: ObjectExpression | ObjectPattern; } interface PropertyNonComputedName { parent: ObjectExpression | ObjectPattern; } interface PropertyDefinitionComputedName { parent: ClassBody; } interface PropertyDefinitionNonComputedName { parent: ClassBody; } interface TSAbstractPropertyDefinitionComputedName { parent: ClassBody; } interface TSAbstractPropertyDefinitionNonComputedName { parent: ClassBody; } interface SpreadElement { parent: ArrayExpression | CallExpression | NewExpression | ObjectExpression; } interface StaticBlock { parent: ClassBody; } interface SwitchCase { parent: SwitchStatement; } interface TemplateElement { parent: TemplateLiteral | TSTemplateLiteralType; } interface TSCallSignatureDeclaration { parent: TSInterfaceBody | TSTypeLiteral; } interface TSConstructSignatureDeclaration { parent: TSInterfaceBody | TSTypeLiteral; } interface TSClassImplements { parent: ClassDeclaration | ClassExpression; } interface TSEnumBody { parent: TSEnumDeclaration; } interface TSEnumMember { parent: TSEnumBody; } interface TSIndexSignature { parent: ClassBody | TSInterfaceBody | TSTypeLiteral; } interface TSInterfaceBody { parent: TSInterfaceDeclaration; } interface TSInterfaceHeritage { parent: TSInterfaceBody; } interface TSMethodSignatureComputedName { parent: TSInterfaceBody | TSTypeLiteral; } interface TSMethodSignatureNonComputedName { parent: TSInterfaceBody | TSTypeLiteral; } interface TSModuleBlock { parent: TSModuleDeclaration; } interface TSParameterProperty { parent: FunctionLike; } interface TSPropertySignatureComputedName { parent: TSInterfaceBody | TSTypeLiteral; } interface TSPropertySignatureNonComputedName { parent: TSInterfaceBody | TSTypeLiteral; } interface TSTypeParameter { parent: TSInferType | TSMappedType | TSTypeParameterDeclaration; } interface ExportSpecifierWithIdentifierLocal { parent: ExportNamedDeclaration; } interface ExportSpecifierWithStringOrLiteralLocal { parent: ExportNamedDeclaration; } } type NodeWithParent = Exclude; //#endregion //#region node_modules/@typescript-eslint/typescript-estree/dist/ts-estree/ts-nodes.d.ts declare module 'typescript' { interface AssertClause extends ts.ImportAttributes {} interface AssertEntry extends ts.ImportAttribute {} interface SatisfiesExpression extends ts.Node {} interface JsxNamespacedName extends ts.Node {} interface ImportAttribute extends ts.Node {} interface ImportAttributes extends ts.Node {} } type TSToken = ts.Token; type TSNode = ts.ArrayBindingPattern | ts.ArrayLiteralExpression | ts.ArrayTypeNode | ts.ArrowFunction | ts.AsExpression | ts.AssertClause | ts.AssertEntry | ts.AwaitExpression | ts.BigIntLiteral | ts.BinaryExpression | ts.BindingElement | ts.Block | ts.BooleanLiteral | ts.BreakStatement | ts.Bundle | ts.CallExpression | ts.CallSignatureDeclaration | ts.CaseBlock | ts.CaseClause | ts.CatchClause | ts.ClassDeclaration | ts.ClassExpression | ts.ClassStaticBlockDeclaration | ts.CommaListExpression | ts.ComputedPropertyName | ts.ConditionalExpression | ts.ConditionalTypeNode | ts.ConstructorDeclaration | ts.ConstructorTypeNode | ts.ConstructSignatureDeclaration | ts.ContinueStatement | ts.DebuggerStatement | ts.Decorator | ts.DefaultClause | ts.DeleteExpression | ts.DoStatement | ts.ElementAccessExpression | ts.EmptyStatement | ts.EnumDeclaration | ts.EnumMember | ts.ExportAssignment | ts.ExportDeclaration | ts.ExportSpecifier | ts.ExpressionStatement | ts.ExpressionWithTypeArguments | ts.ExternalModuleReference | ts.ForInStatement | ts.ForOfStatement | ts.ForStatement | ts.FunctionDeclaration | ts.FunctionExpression | ts.FunctionTypeNode | ts.GetAccessorDeclaration | ts.HeritageClause | ts.Identifier | ts.IfStatement | ts.ImportAttribute | ts.ImportAttributes | ts.ImportClause | ts.ImportDeclaration | ts.ImportEqualsDeclaration | ts.ImportExpression | ts.ImportSpecifier | ts.ImportTypeNode | ts.IndexedAccessTypeNode | ts.IndexSignatureDeclaration | ts.InferTypeNode | ts.InterfaceDeclaration | ts.IntersectionTypeNode | ts.JSDoc | ts.JSDocAllType | ts.JSDocAugmentsTag | ts.JSDocAuthorTag | ts.JSDocCallbackTag | ts.JSDocClassTag | ts.JSDocEnumTag | ts.JSDocFunctionType | ts.JSDocNonNullableType | ts.JSDocNullableType | ts.JSDocOptionalType | ts.JSDocParameterTag | ts.JSDocPropertyTag | ts.JSDocReturnTag | ts.JSDocSignature | ts.JSDocTemplateTag | ts.JSDocThisTag | ts.JSDocTypedefTag | ts.JSDocTypeExpression | ts.JSDocTypeLiteral | ts.JSDocTypeTag | ts.JSDocUnknownTag | ts.JSDocUnknownType | ts.JSDocVariadicType | ts.JsonMinusNumericLiteral | ts.JsxAttribute | ts.JsxClosingElement | ts.JsxClosingFragment | ts.JsxElement | ts.JsxExpression | ts.JsxFragment | ts.JsxNamespacedName | ts.JsxOpeningElement | ts.JsxOpeningFragment | ts.JsxSelfClosingElement | ts.JsxSpreadAttribute | ts.JsxText | ts.KeywordTypeNode | ts.LabeledStatement | ts.LiteralTypeNode | ts.MappedTypeNode | ts.MetaProperty | ts.MethodDeclaration | ts.MethodSignature | ts.MissingDeclaration | ts.Modifier | ts.ModuleBlock | ts.ModuleDeclaration | ts.NamedExports | ts.NamedImports | ts.NamedTupleMember | ts.NamespaceExportDeclaration | ts.NamespaceImport | ts.NewExpression | ts.NonNullExpression | ts.NoSubstitutionTemplateLiteral | ts.NotEmittedStatement | ts.NullLiteral | ts.NumericLiteral | ts.ObjectBindingPattern | ts.ObjectLiteralExpression | ts.OmittedExpression | ts.OptionalTypeNode | ts.ParameterDeclaration | ts.ParenthesizedExpression | ts.ParenthesizedTypeNode | ts.PartiallyEmittedExpression | ts.PostfixUnaryExpression | ts.PrefixUnaryExpression | ts.PrivateIdentifier | ts.PropertyAccessExpression | ts.PropertyAssignment | ts.PropertyDeclaration | ts.PropertySignature | ts.QualifiedName | ts.RegularExpressionLiteral | ts.RestTypeNode | ts.ReturnStatement | ts.SatisfiesExpression | ts.SemicolonClassElement | ts.SetAccessorDeclaration | ts.ShorthandPropertyAssignment | ts.SourceFile | ts.SpreadAssignment | ts.SpreadElement | ts.StringLiteral | ts.SuperExpression | ts.SwitchStatement | ts.SyntheticExpression | ts.TaggedTemplateExpression | ts.TemplateExpression | ts.TemplateHead | ts.TemplateLiteralTypeNode | ts.TemplateMiddle | ts.TemplateSpan | ts.TemplateTail | ts.ThisExpression | ts.ThisTypeNode | ts.ThrowStatement | ts.TryStatement | ts.TupleTypeNode | ts.TypeAliasDeclaration | ts.TypeAssertion | ts.TypeLiteralNode | ts.TypeOfExpression | ts.TypeOperatorNode | ts.TypeParameterDeclaration | ts.TypePredicateNode | ts.TypeQueryNode | ts.TypeReferenceNode | ts.UnionTypeNode | ts.VariableDeclaration | ts.VariableDeclarationList | ts.VariableStatement | ts.VoidExpression | ts.WhileStatement | ts.WithStatement | ts.YieldExpression; //#endregion //#region node_modules/@typescript-eslint/typescript-estree/dist/ts-estree/estree-to-ts-node-types.d.ts interface EstreeToTsNodeTypes { [AST_NODE_TYPES.AccessorProperty]: ts.PropertyDeclaration; [AST_NODE_TYPES.ArrayExpression]: ts.ArrayLiteralExpression; [AST_NODE_TYPES.ArrayPattern]: ts.ArrayBindingPattern | ts.ArrayLiteralExpression; [AST_NODE_TYPES.ArrowFunctionExpression]: ts.ArrowFunction; [AST_NODE_TYPES.AssignmentExpression]: ts.BinaryExpression; [AST_NODE_TYPES.AssignmentPattern]: ts.BinaryExpression | ts.BindingElement | ts.ParameterDeclaration | ts.ShorthandPropertyAssignment; [AST_NODE_TYPES.AwaitExpression]: ts.AwaitExpression; [AST_NODE_TYPES.BinaryExpression]: ts.BinaryExpression; [AST_NODE_TYPES.BlockStatement]: ts.Block; [AST_NODE_TYPES.BreakStatement]: ts.BreakStatement; [AST_NODE_TYPES.CallExpression]: ts.CallExpression; [AST_NODE_TYPES.CatchClause]: ts.CatchClause; [AST_NODE_TYPES.ChainExpression]: ts.CallExpression | ts.ElementAccessExpression | ts.NonNullExpression | ts.PropertyAccessExpression; [AST_NODE_TYPES.ClassBody]: ts.ClassDeclaration | ts.ClassExpression; [AST_NODE_TYPES.ClassDeclaration]: ts.ClassDeclaration; [AST_NODE_TYPES.ClassExpression]: ts.ClassExpression; [AST_NODE_TYPES.ConditionalExpression]: ts.ConditionalExpression; [AST_NODE_TYPES.ContinueStatement]: ts.ContinueStatement; [AST_NODE_TYPES.DebuggerStatement]: ts.DebuggerStatement; [AST_NODE_TYPES.Decorator]: ts.Decorator; [AST_NODE_TYPES.DoWhileStatement]: ts.DoStatement; [AST_NODE_TYPES.EmptyStatement]: ts.EmptyStatement; [AST_NODE_TYPES.ExportAllDeclaration]: ts.ExportDeclaration; [AST_NODE_TYPES.ExportDefaultDeclaration]: ts.ClassDeclaration | ts.ClassExpression | ts.EnumDeclaration | ts.ExportAssignment | ts.FunctionDeclaration | ts.InterfaceDeclaration | ts.ModuleDeclaration | ts.TypeAliasDeclaration | ts.VariableStatement; [AST_NODE_TYPES.ExportNamedDeclaration]: ts.ClassDeclaration | ts.ClassExpression | ts.EnumDeclaration | ts.ExportDeclaration | ts.FunctionDeclaration | ts.ImportEqualsDeclaration | ts.InterfaceDeclaration | ts.ModuleDeclaration | ts.TypeAliasDeclaration | ts.VariableStatement; [AST_NODE_TYPES.ExportSpecifier]: ts.ExportSpecifier; [AST_NODE_TYPES.ExpressionStatement]: ts.ExpressionStatement; [AST_NODE_TYPES.ForInStatement]: ts.ForInStatement; [AST_NODE_TYPES.ForOfStatement]: ts.ForOfStatement; [AST_NODE_TYPES.ForStatement]: ts.ForStatement; [AST_NODE_TYPES.FunctionDeclaration]: ts.FunctionDeclaration; [AST_NODE_TYPES.FunctionExpression]: ts.ConstructorDeclaration | ts.FunctionExpression | ts.GetAccessorDeclaration | ts.MethodDeclaration | ts.SetAccessorDeclaration; [AST_NODE_TYPES.Identifier]: ts.ConstructorDeclaration | ts.Identifier | ts.Token; [AST_NODE_TYPES.IfStatement]: ts.IfStatement; [AST_NODE_TYPES.PrivateIdentifier]: ts.PrivateIdentifier; [AST_NODE_TYPES.PropertyDefinition]: ts.PropertyDeclaration; [AST_NODE_TYPES.ImportAttribute]: 'ImportAttribute' extends keyof typeof ts ? ts.ImportAttribute : ts.AssertEntry; [AST_NODE_TYPES.ImportDeclaration]: ts.ImportDeclaration; [AST_NODE_TYPES.ImportDefaultSpecifier]: ts.ImportClause; [AST_NODE_TYPES.ImportExpression]: ts.CallExpression; [AST_NODE_TYPES.ImportNamespaceSpecifier]: ts.NamespaceImport; [AST_NODE_TYPES.ImportSpecifier]: ts.ImportSpecifier; [AST_NODE_TYPES.JSXAttribute]: ts.JsxAttribute; [AST_NODE_TYPES.JSXClosingElement]: ts.JsxClosingElement; [AST_NODE_TYPES.JSXClosingFragment]: ts.JsxClosingFragment; [AST_NODE_TYPES.JSXElement]: ts.JsxElement | ts.JsxSelfClosingElement; [AST_NODE_TYPES.JSXEmptyExpression]: ts.JsxExpression; [AST_NODE_TYPES.JSXExpressionContainer]: ts.JsxExpression; [AST_NODE_TYPES.JSXFragment]: ts.JsxFragment; [AST_NODE_TYPES.JSXIdentifier]: ts.Identifier | ts.ThisExpression; [AST_NODE_TYPES.JSXMemberExpression]: ts.PropertyAccessExpression; [AST_NODE_TYPES.JSXNamespacedName]: ts.JsxNamespacedName; [AST_NODE_TYPES.JSXOpeningElement]: ts.JsxOpeningElement | ts.JsxSelfClosingElement; [AST_NODE_TYPES.JSXOpeningFragment]: ts.JsxOpeningFragment; [AST_NODE_TYPES.JSXSpreadAttribute]: ts.JsxSpreadAttribute; [AST_NODE_TYPES.JSXSpreadChild]: ts.JsxExpression; [AST_NODE_TYPES.JSXText]: ts.JsxText; [AST_NODE_TYPES.LabeledStatement]: ts.LabeledStatement; [AST_NODE_TYPES.Literal]: ts.BigIntLiteral | ts.BooleanLiteral | ts.NullLiteral | ts.NumericLiteral | ts.RegularExpressionLiteral | ts.StringLiteral; [AST_NODE_TYPES.LogicalExpression]: ts.BinaryExpression; [AST_NODE_TYPES.MemberExpression]: ts.ElementAccessExpression | ts.PropertyAccessExpression; [AST_NODE_TYPES.MetaProperty]: ts.MetaProperty; [AST_NODE_TYPES.MethodDefinition]: ts.ConstructorDeclaration | ts.GetAccessorDeclaration | ts.MethodDeclaration | ts.SetAccessorDeclaration; [AST_NODE_TYPES.NewExpression]: ts.NewExpression; [AST_NODE_TYPES.ObjectExpression]: ts.ObjectLiteralExpression; [AST_NODE_TYPES.ObjectPattern]: ts.ObjectBindingPattern | ts.ObjectLiteralExpression; [AST_NODE_TYPES.Program]: ts.SourceFile; [AST_NODE_TYPES.Property]: ts.BindingElement | ts.GetAccessorDeclaration | ts.MethodDeclaration | ts.PropertyAssignment | ts.SetAccessorDeclaration | ts.ShorthandPropertyAssignment; [AST_NODE_TYPES.RestElement]: ts.BindingElement | ts.ParameterDeclaration | ts.SpreadAssignment | ts.SpreadElement; [AST_NODE_TYPES.ReturnStatement]: ts.ReturnStatement; [AST_NODE_TYPES.SequenceExpression]: ts.BinaryExpression; [AST_NODE_TYPES.SpreadElement]: ts.SpreadAssignment | ts.SpreadElement; [AST_NODE_TYPES.StaticBlock]: ts.ClassStaticBlockDeclaration; [AST_NODE_TYPES.Super]: ts.SuperExpression; [AST_NODE_TYPES.SwitchCase]: ts.CaseClause | ts.DefaultClause; [AST_NODE_TYPES.SwitchStatement]: ts.SwitchStatement; [AST_NODE_TYPES.TaggedTemplateExpression]: ts.TaggedTemplateExpression; [AST_NODE_TYPES.TemplateElement]: ts.NoSubstitutionTemplateLiteral | ts.TemplateHead | ts.TemplateMiddle | ts.TemplateTail; [AST_NODE_TYPES.TemplateLiteral]: ts.NoSubstitutionTemplateLiteral | ts.TemplateExpression; [AST_NODE_TYPES.ThisExpression]: ts.Identifier | ts.KeywordTypeNode | ts.ThisExpression; [AST_NODE_TYPES.ThrowStatement]: ts.ThrowStatement; [AST_NODE_TYPES.TryStatement]: ts.TryStatement; [AST_NODE_TYPES.TSAbstractAccessorProperty]: ts.PropertyDeclaration; [AST_NODE_TYPES.TSAbstractMethodDefinition]: ts.ConstructorDeclaration | ts.GetAccessorDeclaration | ts.MethodDeclaration | ts.SetAccessorDeclaration; [AST_NODE_TYPES.TSAbstractPropertyDefinition]: ts.PropertyDeclaration; [AST_NODE_TYPES.TSArrayType]: ts.ArrayTypeNode; [AST_NODE_TYPES.TSAsExpression]: ts.AsExpression; [AST_NODE_TYPES.TSCallSignatureDeclaration]: ts.CallSignatureDeclaration; [AST_NODE_TYPES.TSClassImplements]: ts.ExpressionWithTypeArguments; [AST_NODE_TYPES.TSConditionalType]: ts.ConditionalTypeNode; [AST_NODE_TYPES.TSConstructorType]: ts.ConstructorTypeNode; [AST_NODE_TYPES.TSConstructSignatureDeclaration]: ts.ConstructSignatureDeclaration; [AST_NODE_TYPES.TSDeclareFunction]: ts.FunctionDeclaration; [AST_NODE_TYPES.TSEnumBody]: ts.EnumDeclaration; [AST_NODE_TYPES.TSEnumDeclaration]: ts.EnumDeclaration; [AST_NODE_TYPES.TSEnumMember]: ts.EnumMember; [AST_NODE_TYPES.TSExportAssignment]: ts.ExportAssignment; [AST_NODE_TYPES.TSExternalModuleReference]: ts.ExternalModuleReference; [AST_NODE_TYPES.TSFunctionType]: ts.FunctionTypeNode; [AST_NODE_TYPES.TSImportEqualsDeclaration]: ts.ImportEqualsDeclaration; [AST_NODE_TYPES.TSImportType]: ts.ImportTypeNode; [AST_NODE_TYPES.TSIndexedAccessType]: ts.IndexedAccessTypeNode; [AST_NODE_TYPES.TSIndexSignature]: ts.IndexSignatureDeclaration; [AST_NODE_TYPES.TSInferType]: ts.InferTypeNode; [AST_NODE_TYPES.TSInstantiationExpression]: ts.ExpressionWithTypeArguments; [AST_NODE_TYPES.TSInterfaceBody]: ts.InterfaceDeclaration; [AST_NODE_TYPES.TSInterfaceDeclaration]: ts.InterfaceDeclaration; [AST_NODE_TYPES.TSInterfaceHeritage]: ts.ExpressionWithTypeArguments; [AST_NODE_TYPES.TSIntersectionType]: ts.IntersectionTypeNode; [AST_NODE_TYPES.TSLiteralType]: ts.LiteralTypeNode; [AST_NODE_TYPES.TSMappedType]: ts.MappedTypeNode; [AST_NODE_TYPES.TSMethodSignature]: ts.GetAccessorDeclaration | ts.MethodSignature | ts.SetAccessorDeclaration; [AST_NODE_TYPES.TSModuleBlock]: ts.ModuleBlock; [AST_NODE_TYPES.TSModuleDeclaration]: ts.ModuleDeclaration; [AST_NODE_TYPES.TSNamedTupleMember]: ts.NamedTupleMember; [AST_NODE_TYPES.TSNamespaceExportDeclaration]: ts.NamespaceExportDeclaration; [AST_NODE_TYPES.TSNonNullExpression]: ts.NonNullExpression; [AST_NODE_TYPES.TSOptionalType]: ts.OptionalTypeNode; [AST_NODE_TYPES.TSParameterProperty]: ts.ParameterDeclaration; [AST_NODE_TYPES.TSPropertySignature]: ts.PropertySignature; [AST_NODE_TYPES.TSQualifiedName]: ts.Identifier | ts.QualifiedName; [AST_NODE_TYPES.TSRestType]: ts.NamedTupleMember | ts.RestTypeNode; [AST_NODE_TYPES.TSSatisfiesExpression]: ts.SatisfiesExpression; [AST_NODE_TYPES.TSTemplateLiteralType]: ts.TemplateLiteralTypeNode; [AST_NODE_TYPES.TSThisType]: ts.ThisTypeNode; [AST_NODE_TYPES.TSTupleType]: ts.TupleTypeNode; [AST_NODE_TYPES.TSTypeAliasDeclaration]: ts.TypeAliasDeclaration; [AST_NODE_TYPES.TSTypeAnnotation]: undefined; [AST_NODE_TYPES.TSTypeAssertion]: ts.TypeAssertion; [AST_NODE_TYPES.TSTypeLiteral]: ts.TypeLiteralNode; [AST_NODE_TYPES.TSTypeOperator]: ts.TypeOperatorNode; [AST_NODE_TYPES.TSTypeParameter]: ts.TypeParameterDeclaration; [AST_NODE_TYPES.TSTypeParameterDeclaration]: undefined; [AST_NODE_TYPES.TSTypeParameterInstantiation]: ts.CallExpression | ts.ExpressionWithTypeArguments | ts.ImportTypeNode | ts.JsxOpeningElement | ts.JsxSelfClosingElement | ts.NewExpression | ts.TaggedTemplateExpression | ts.TypeQueryNode | ts.TypeReferenceNode; [AST_NODE_TYPES.TSTypePredicate]: ts.TypePredicateNode; [AST_NODE_TYPES.TSTypeQuery]: ts.ImportTypeNode | ts.TypeQueryNode; [AST_NODE_TYPES.TSTypeReference]: ts.TypeReferenceNode; [AST_NODE_TYPES.TSUnionType]: ts.UnionTypeNode; [AST_NODE_TYPES.UnaryExpression]: ts.DeleteExpression | ts.PostfixUnaryExpression | ts.PrefixUnaryExpression | ts.TypeOfExpression | ts.VoidExpression; [AST_NODE_TYPES.UpdateExpression]: ts.PostfixUnaryExpression | ts.PrefixUnaryExpression; [AST_NODE_TYPES.VariableDeclaration]: ts.VariableDeclarationList | ts.VariableStatement; [AST_NODE_TYPES.VariableDeclarator]: ts.VariableDeclaration; [AST_NODE_TYPES.WhileStatement]: ts.WhileStatement; [AST_NODE_TYPES.WithStatement]: ts.WithStatement; [AST_NODE_TYPES.YieldExpression]: ts.YieldExpression; [AST_NODE_TYPES.TSEmptyBodyFunctionExpression]: ts.ConstructorDeclaration | ts.FunctionExpression | ts.GetAccessorDeclaration | ts.MethodDeclaration | ts.SetAccessorDeclaration; [AST_NODE_TYPES.TSAbstractKeyword]: ts.Token; [AST_NODE_TYPES.TSAnyKeyword]: ts.KeywordTypeNode; [AST_NODE_TYPES.TSBigIntKeyword]: ts.KeywordTypeNode; [AST_NODE_TYPES.TSBooleanKeyword]: ts.KeywordTypeNode; [AST_NODE_TYPES.TSIntrinsicKeyword]: ts.KeywordTypeNode; [AST_NODE_TYPES.TSNeverKeyword]: ts.KeywordTypeNode; [AST_NODE_TYPES.TSNullKeyword]: ts.KeywordTypeNode | ts.NullLiteral; [AST_NODE_TYPES.TSNumberKeyword]: ts.KeywordTypeNode; [AST_NODE_TYPES.TSObjectKeyword]: ts.KeywordTypeNode; [AST_NODE_TYPES.TSStringKeyword]: ts.KeywordTypeNode; [AST_NODE_TYPES.TSSymbolKeyword]: ts.KeywordTypeNode; [AST_NODE_TYPES.TSUndefinedKeyword]: ts.KeywordTypeNode; [AST_NODE_TYPES.TSUnknownKeyword]: ts.KeywordTypeNode; [AST_NODE_TYPES.TSVoidKeyword]: ts.KeywordTypeNode; [AST_NODE_TYPES.TSAsyncKeyword]: ts.Token; [AST_NODE_TYPES.TSDeclareKeyword]: ts.Token; [AST_NODE_TYPES.TSExportKeyword]: ts.Token; [AST_NODE_TYPES.TSPrivateKeyword]: ts.Token; [AST_NODE_TYPES.TSProtectedKeyword]: ts.Token; [AST_NODE_TYPES.TSPublicKeyword]: ts.Token; [AST_NODE_TYPES.TSReadonlyKeyword]: ts.Token; [AST_NODE_TYPES.TSStaticKeyword]: ts.Token; } /** * Maps TSESTree AST Node type to the expected TypeScript AST Node type(s). * This mapping is based on the internal logic of the parser. */ type TSESTreeToTSNode = Extract | TSNode, EstreeToTsNodeTypes[T['type']]>; //#endregion //#region node_modules/@typescript-eslint/typescript-estree/dist/parseSettings/index.d.ts declare module 'typescript' { enum JSDocParsingMode {} } declare module 'typescript/lib/tsserverlibrary' { enum JSDocParsingMode {} } /** * Internal settings used by the parser to run on a file. */ //#endregion //#region node_modules/@typescript-eslint/typescript-estree/dist/parser-options.d.ts interface ParserWeakMap { get(key: Key): Value; has(key: unknown): boolean; } interface ParserWeakMapESTreeToTSNode { get(key: KeyBase): TSESTreeToTSNode; has(key: unknown): boolean; } interface ParserServicesBase { emitDecoratorMetadata: boolean | undefined; experimentalDecorators: boolean | undefined; isolatedDeclarations: boolean | undefined; } interface ParserServicesNodeMaps { esTreeNodeToTSNodeMap: ParserWeakMapESTreeToTSNode; tsNodeToESTreeNodeMap: ParserWeakMap; } interface ParserServicesWithTypeInformation extends ParserServicesNodeMaps, ParserServicesBase { getSymbolAtLocation: (node: Node) => ts.Symbol | undefined; getTypeAtLocation: (node: Node) => ts.Type; getContextualType: (node: Expression) => ts.Type | undefined; getResolvedSignature: (node: CallExpression | NewExpression) => ts.Signature | undefined; getTypeFromTypeNode: (node: TypeNode) => ts.Type; getTypeOfSymbolAtLocation: (symbol: ts.Symbol, node: Node) => ts.Type; program: ts.Program; } interface ParserServicesWithoutTypeInformation extends ParserServicesNodeMaps, ParserServicesBase { program: null; } type ParserServices = ParserServicesWithoutTypeInformation | ParserServicesWithTypeInformation; //#endregion //#region node_modules/@typescript-eslint/utils/dist/ts-eslint/AST.d.ts declare namespace AST { type TokenType = AST_TOKEN_TYPES; type Token = Token; type SourceLocation = SourceLocation; type Range = Range; } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/definition/DefinitionType.d.ts declare enum DefinitionType { CatchClause = "CatchClause", ClassName = "ClassName", FunctionName = "FunctionName", ImplicitGlobalVariable = "ImplicitGlobalVariable", ImportBinding = "ImportBinding", Parameter = "Parameter", TSEnumName = "TSEnumName", TSEnumMember = "TSEnumMemberName", TSModuleName = "TSModuleName", Type = "Type", Variable = "Variable" } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/definition/DefinitionBase.d.ts declare abstract class DefinitionBase { /** * A unique ID for this instance - primarily used to help debugging and testing */ readonly $id: number; readonly type: Type; /** * The `Identifier` node of this definition * @public */ readonly name: Name; /** * The enclosing node of the name. * @public */ readonly node: Node$1; /** * the enclosing statement node of the identifier. * @public */ readonly parent: Parent; constructor(type: Type, name: Name, node: Node$1, parent: Parent); /** * `true` if the variable is valid in a type context, false otherwise */ abstract readonly isTypeDefinition: boolean; /** * `true` if the variable is valid in a value context, false otherwise */ abstract readonly isVariableDefinition: boolean; } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/definition/CatchClauseDefinition.d.ts declare class CatchClauseDefinition extends DefinitionBase { readonly isTypeDefinition = false; readonly isVariableDefinition = true; constructor(name: Identifier, node: CatchClauseDefinition['node']); } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/definition/ClassNameDefinition.d.ts declare class ClassNameDefinition extends DefinitionBase { readonly isTypeDefinition = true; readonly isVariableDefinition = true; constructor(name: Identifier, node: ClassNameDefinition['node']); } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/definition/FunctionNameDefinition.d.ts declare class FunctionNameDefinition extends DefinitionBase { readonly isTypeDefinition = false; readonly isVariableDefinition = true; constructor(name: Identifier, node: FunctionNameDefinition['node']); } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/definition/ImplicitGlobalVariableDefinition.d.ts declare class ImplicitGlobalVariableDefinition extends DefinitionBase { readonly isTypeDefinition = false; readonly isVariableDefinition = true; constructor(name: BindingName, node: ImplicitGlobalVariableDefinition['node']); } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/definition/ImportBindingDefinition.d.ts declare class ImportBindingDefinition extends DefinitionBase { readonly isTypeDefinition = true; readonly isVariableDefinition = true; constructor(name: Identifier, node: TSImportEqualsDeclaration, decl: TSImportEqualsDeclaration); constructor(name: Identifier, node: Exclude, decl: ImportDeclaration); } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/definition/ParameterDefinition.d.ts declare class ParameterDefinition extends DefinitionBase { /** * Whether the parameter definition is a part of a rest parameter. */ readonly isTypeDefinition = false; readonly isVariableDefinition = true; readonly rest: boolean; constructor(name: BindingName, node: ParameterDefinition['node'], rest: boolean); } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/definition/TSEnumMemberDefinition.d.ts declare class TSEnumMemberDefinition extends DefinitionBase { readonly isTypeDefinition = true; readonly isVariableDefinition = true; constructor(name: Identifier | StringLiteral, node: TSEnumMemberDefinition['node']); } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/definition/TSEnumNameDefinition.d.ts declare class TSEnumNameDefinition extends DefinitionBase { readonly isTypeDefinition = true; readonly isVariableDefinition = true; constructor(name: Identifier, node: TSEnumNameDefinition['node']); } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/definition/TSModuleNameDefinition.d.ts declare class TSModuleNameDefinition extends DefinitionBase { readonly isTypeDefinition = true; readonly isVariableDefinition = true; constructor(name: Identifier, node: TSModuleNameDefinition['node']); } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/definition/TypeDefinition.d.ts declare class TypeDefinition extends DefinitionBase { readonly isTypeDefinition = true; readonly isVariableDefinition = false; constructor(name: Identifier, node: TypeDefinition['node']); } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/definition/VariableDefinition.d.ts declare class VariableDefinition extends DefinitionBase { readonly isTypeDefinition = false; readonly isVariableDefinition = true; constructor(name: Identifier, node: VariableDefinition['node'], decl: VariableDeclaration); } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/definition/Definition.d.ts type Definition = CatchClauseDefinition | ClassNameDefinition | FunctionNameDefinition | ImplicitGlobalVariableDefinition | ImportBindingDefinition | ParameterDefinition | TSEnumMemberDefinition | TSEnumNameDefinition | TSModuleNameDefinition | TypeDefinition | VariableDefinition; //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/referencer/Reference.d.ts declare enum ReferenceFlag { Read = 1, Write = 2, ReadWrite = 3 } interface ReferenceImplicitGlobal { node: NodeWithParent; pattern: BindingName; ref?: Reference; } declare enum ReferenceTypeFlag { Value = 1, Type = 2 } /** * A Reference represents a single occurrence of an identifier in code. */ declare class Reference { #private; /** * A unique ID for this instance - primarily used to help debugging and testing */ readonly $id: number; /** * Reference to the enclosing Scope. * @public */ readonly from: Scope$1; /** * Identifier syntax node. * @public */ readonly identifier: Identifier | JSXIdentifier; /** * `true` if this writing reference is a variable initializer or a default value. * @public */ readonly init?: boolean; readonly maybeImplicitGlobal?: ReferenceImplicitGlobal | null; /** * The {@link Variable} object that this reference refers to. If such variable was not defined, this is `null`. * @public */ resolved: Variable | null; /** * If reference is writeable, this is the node being written to it. * @public */ readonly writeExpr?: Node | null; constructor(identifier: Identifier | JSXIdentifier, scope: Scope$1, flag: ReferenceFlag, writeExpr?: Node | null, maybeImplicitGlobal?: ReferenceImplicitGlobal | null, init?: boolean, referenceType?: ReferenceTypeFlag); /** * True if this reference can reference types */ get isTypeReference(): boolean; /** * True if this reference can reference values */ get isValueReference(): boolean; /** * Whether the reference is writeable. * @public */ isWrite(): boolean; /** * Whether the reference is readable. * @public */ isRead(): boolean; /** * Whether the reference is read-only. * @public */ isReadOnly(): boolean; /** * Whether the reference is write-only. * @public */ isWriteOnly(): boolean; /** * Whether the reference is read-write. * @public */ isReadWrite(): boolean; } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/variable/VariableBase.d.ts declare class VariableBase { /** * A unique ID for this instance - primarily used to help debugging and testing */ readonly $id: number; /** * The array of the definitions of this variable. * @public */ readonly defs: Definition[]; /** * True if the variable is considered used for the purposes of `no-unused-vars`, false otherwise. * @public */ eslintUsed: boolean; /** * The array of `Identifier` nodes which define this variable. * If this variable is redeclared, this array includes two or more nodes. * @public */ readonly identifiers: Identifier[]; /** * The variable name, as given in the source code. * @public */ readonly name: string; /** * List of {@link Reference} of this variable (excluding parameter entries) in its defining scope and all nested scopes. * For defining occurrences only see {@link Variable#defs}. * @public */ readonly references: Reference[]; /** * Reference to the enclosing Scope. */ readonly scope: Scope$1; constructor(name: string, scope: Scope$1); } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/variable/ESLintScopeVariable.d.ts /** * ESLint defines global variables using the eslint-scope Variable class * This is declared here for consumers to use */ declare class ESLintScopeVariable extends VariableBase { /** * Written to by ESLint. * If this key exists, this variable is a global variable added by ESLint. * If this is `true`, this variable can be assigned arbitrary values. * If this is `false`, this variable is readonly. */ writeable?: boolean; /** * Written to by ESLint. * This property is undefined if there are no globals comment directives. * The array of globals comment directives which defined this global variable in the source code file. */ eslintExplicitGlobal?: boolean; /** * Written to by ESLint. * The configured value in config files. This can be different from `variable.writeable` if there are globals comment directives. */ eslintImplicitGlobalSetting?: 'readonly' | 'writable'; /** * Written to by ESLint. * If this key exists, it is a global variable added by ESLint. * If `true`, this global variable was defined by a globals comment directive in the source code file. */ eslintExplicitGlobalComments?: Comment[]; } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/variable/Variable.d.ts /** * A Variable represents a locally scoped identifier. These include arguments to functions. */ declare class Variable extends VariableBase { /** * `true` if the variable is valid in a type context, false otherwise * @public */ get isTypeVariable(): boolean; /** * `true` if the variable is valid in a value context, false otherwise * @public */ get isValueVariable(): boolean; } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/variable/ImplicitLibVariable.d.ts interface ImplicitLibVariableOptions { readonly eslintImplicitGlobalSetting?: ESLintScopeVariable['eslintImplicitGlobalSetting']; readonly isTypeVariable?: boolean; readonly isValueVariable?: boolean; readonly writeable?: boolean; } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/variable/index.d.ts type ScopeVariable = ESLintScopeVariable | Variable; //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/scope/ScopeType.d.ts declare enum ScopeType { block = "block", catch = "catch", class = "class", classFieldInitializer = "class-field-initializer", classStaticBlock = "class-static-block", conditionalType = "conditionalType", for = "for", function = "function", functionExpressionName = "function-expression-name", functionType = "functionType", global = "global", mappedType = "mappedType", module = "module", switch = "switch", tsEnum = "tsEnum", tsModule = "tsModule", type = "type", with = "with" } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/scope/FunctionScope.d.ts declare class FunctionScope extends ScopeBase { constructor(scopeManager: ScopeManager, upperScope: FunctionScope['upper'], block: FunctionScope['block'], isMethodDefinition: boolean); protected isValidResolution(ref: Reference, variable: Variable): boolean; } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/scope/GlobalScope.d.ts declare class GlobalScope extends ScopeBase { private readonly implicit; constructor(scopeManager: ScopeManager, block: GlobalScope['block']); addVariables(names: string[]): void; close(scopeManager: ScopeManager): Scope$1 | null; defineImplicitVariable(name: string, options: ImplicitLibVariableOptions): void; } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/scope/ModuleScope.d.ts declare class ModuleScope extends ScopeBase { constructor(scopeManager: ScopeManager, upperScope: ModuleScope['upper'], block: ModuleScope['block']); } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/scope/TSModuleScope.d.ts declare class TSModuleScope extends ScopeBase { constructor(scopeManager: ScopeManager, upperScope: TSModuleScope['upper'], block: TSModuleScope['block']); } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/scope/ScopeBase.d.ts type VariableScope = FunctionScope | GlobalScope | ModuleScope | TSModuleScope; declare abstract class ScopeBase { #private; /** * A unique ID for this instance - primarily used to help debugging and testing */ readonly $id: number; /** * The AST node which created this scope. * @public */ readonly block: Block; /** * The array of child scopes. This does not include grandchild scopes. * @public */ readonly childScopes: Scope$1[]; /** * Whether this scope is created by a FunctionExpression. * @public */ readonly functionExpressionScope: boolean; /** * Whether 'use strict' is in effect in this scope. * @public */ isStrict: boolean; /** * List of {@link Reference}s that are left to be resolved (i.e. which * need to be linked to the variable they refer to). */ protected leftToResolve: Reference[] | null; /** * Any variable {@link Reference} found in this scope. * This includes occurrences of local variables as well as variables from parent scopes (including the global scope). * For local variables this also includes defining occurrences (like in a 'var' statement). * In a 'function' scope this does not include the occurrences of the formal parameter in the parameter list. * @public */ readonly references: Reference[]; /** * The map from variable names to variable objects. * @public */ readonly set: Map; /** * The {@link Reference}s that are not resolved with this scope. * @public */ through: Reference[]; readonly type: Type; /** * Reference to the parent {@link Scope}. * @public */ readonly upper: Upper; /** * The scoped {@link Variable}s of this scope. * In the case of a 'function' scope this includes the automatic argument `arguments` as its first element, as well * as all further formal arguments. * This does not include variables which are defined in child scopes. * @public */ readonly variables: Variable[]; readonly variableScope: VariableScope; constructor(scopeManager: ScopeManager, type: Type, upperScope: Upper, block: Block, isMethodDefinition: boolean); private isVariableScope; close(_scopeManager: ScopeManager): Scope$1 | null; shouldStaticallyClose(): boolean; /** * To override by function scopes. * References in default parameters isn't resolved to variables which are in their function body. */ protected defineVariable(nameOrVariable: string | Variable, set: Map, variables: Variable[], node: Identifier | null, def: Definition | null): void; protected delegateToUpperScope(ref: Reference): void; protected isValidResolution(_ref: Reference, _variable: Variable): boolean; private addDeclaredVariablesOfNode; defineIdentifier(node: Identifier, def: Definition): void; defineLiteralIdentifier(node: StringLiteral, def: Definition): void; referenceDualValueType(node: Identifier): void; referenceType(node: Identifier): void; referenceValue(node: Identifier | JSXIdentifier, assign?: ReferenceFlag, writeExpr?: Expression | null, maybeImplicitGlobal?: ReferenceImplicitGlobal | null, init?: boolean): void; } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/scope/CatchScope.d.ts declare class CatchScope extends ScopeBase { constructor(scopeManager: ScopeManager, upperScope: CatchScope['upper'], block: CatchScope['block']); } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/scope/ClassScope.d.ts declare class ClassScope extends ScopeBase { constructor(scopeManager: ScopeManager, upperScope: ClassScope['upper'], block: ClassScope['block']); } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/scope/ClassStaticBlockScope.d.ts declare class ClassStaticBlockScope extends ScopeBase { constructor(scopeManager: ScopeManager, upperScope: ClassStaticBlockScope['upper'], block: ClassStaticBlockScope['block']); } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/scope/ConditionalTypeScope.d.ts declare class ConditionalTypeScope extends ScopeBase { constructor(scopeManager: ScopeManager, upperScope: ConditionalTypeScope['upper'], block: ConditionalTypeScope['block']); } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/scope/ForScope.d.ts declare class ForScope extends ScopeBase { constructor(scopeManager: ScopeManager, upperScope: ForScope['upper'], block: ForScope['block']); } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/scope/FunctionExpressionNameScope.d.ts declare class FunctionExpressionNameScope extends ScopeBase { readonly functionExpressionScope: true; constructor(scopeManager: ScopeManager, upperScope: FunctionExpressionNameScope['upper'], block: FunctionExpressionNameScope['block']); } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/scope/FunctionTypeScope.d.ts declare class FunctionTypeScope extends ScopeBase { constructor(scopeManager: ScopeManager, upperScope: FunctionTypeScope['upper'], block: FunctionTypeScope['block']); } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/scope/MappedTypeScope.d.ts declare class MappedTypeScope extends ScopeBase { constructor(scopeManager: ScopeManager, upperScope: MappedTypeScope['upper'], block: MappedTypeScope['block']); } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/scope/SwitchScope.d.ts declare class SwitchScope extends ScopeBase { constructor(scopeManager: ScopeManager, upperScope: SwitchScope['upper'], block: SwitchScope['block']); } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/scope/TSEnumScope.d.ts declare class TSEnumScope extends ScopeBase { constructor(scopeManager: ScopeManager, upperScope: TSEnumScope['upper'], block: TSEnumScope['block']); } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/scope/TypeScope.d.ts declare class TypeScope extends ScopeBase { constructor(scopeManager: ScopeManager, upperScope: TypeScope['upper'], block: TypeScope['block']); } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/scope/WithScope.d.ts declare class WithScope extends ScopeBase { constructor(scopeManager: ScopeManager, upperScope: WithScope['upper'], block: WithScope['block']); close(scopeManager: ScopeManager): Scope$1 | null; } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/scope/Scope.d.ts type Scope$1 = BlockScope | CatchScope | ClassFieldInitializerScope | ClassScope | ClassStaticBlockScope | ConditionalTypeScope | ForScope | FunctionExpressionNameScope | FunctionScope | FunctionTypeScope | GlobalScope | MappedTypeScope | ModuleScope | SwitchScope | TSEnumScope | TSModuleScope | TypeScope | WithScope; //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/scope/ClassFieldInitializerScope.d.ts declare class ClassFieldInitializerScope extends ScopeBase { constructor(scopeManager: ScopeManager, upperScope: ClassFieldInitializerScope['upper'], block: ClassFieldInitializerScope['block']); } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/ScopeManager.d.ts interface ScopeManagerOptions { globalReturn?: boolean; impliedStrict?: boolean; sourceType?: SourceType$1; } /** * @see https://eslint.org/docs/latest/developer-guide/scope-manager-interface#scopemanager-interface */ declare class ScopeManager { #private; currentScope: Scope$1 | null; readonly declaredVariables: WeakMap; /** * The root scope */ globalScope: GlobalScope | null; readonly nodeToScope: WeakMap; /** * All scopes * @public */ readonly scopes: Scope$1[]; constructor(options: ScopeManagerOptions); isES6(): boolean; isGlobalReturn(): boolean; isImpliedStrict(): boolean; isModule(): boolean; isStrictModeSupported(): boolean; get variables(): Variable[]; /** * Get the variables that a given AST node defines. The gotten variables' `def[].node`/`def[].parent` property is the node. * If the node does not define any variable, this returns an empty array. * @param node An AST node to get their variables. */ getDeclaredVariables(node: Node): Variable[]; /** * Get the scope of a given AST node. The gotten scope's `block` property is the node. * This method never returns `function-expression-name` scope. If the node does not have their scope, this returns `null`. * * @param node An AST node to get their scope. * @param inner If the node has multiple scopes, this returns the outermost scope normally. * If `inner` is `true` then this returns the innermost scope. */ acquire(node: Node, inner?: boolean): Scope$1 | null; /** * Adds dynamically created globals to the global scope and resolve their references. * This method is called by ESLint. * @param names Names of the globals to create */ addGlobals(names: string[]): void; nestBlockScope(node: BlockScope['block']): BlockScope; nestCatchScope(node: CatchScope['block']): CatchScope; nestClassFieldInitializerScope(node: ClassFieldInitializerScope['block']): ClassFieldInitializerScope; nestClassScope(node: ClassScope['block']): ClassScope; nestClassStaticBlockScope(node: ClassStaticBlockScope['block']): ClassStaticBlockScope; nestConditionalTypeScope(node: ConditionalTypeScope['block']): ConditionalTypeScope; nestForScope(node: ForScope['block']): ForScope; nestFunctionExpressionNameScope(node: FunctionExpressionNameScope['block']): FunctionExpressionNameScope; nestFunctionScope(node: FunctionScope['block'], isMethodDefinition: boolean): FunctionScope; nestFunctionTypeScope(node: FunctionTypeScope['block']): FunctionTypeScope; nestGlobalScope(node: GlobalScope['block']): GlobalScope; nestMappedTypeScope(node: MappedTypeScope['block']): MappedTypeScope; nestModuleScope(node: ModuleScope['block']): ModuleScope; nestSwitchScope(node: SwitchScope['block']): SwitchScope; nestTSEnumScope(node: TSEnumScope['block']): TSEnumScope; nestTSModuleScope(node: TSModuleScope['block']): TSModuleScope; nestTypeScope(node: TypeScope['block']): TypeScope; nestWithScope(node: WithScope['block']): WithScope; protected nestScope(scope: T): T; } //#endregion //#region node_modules/@typescript-eslint/scope-manager/dist/scope/BlockScope.d.ts declare class BlockScope extends ScopeBase { constructor(scopeManager: ScopeManager, upperScope: BlockScope['upper'], block: BlockScope['block']); } //#endregion //#region node_modules/@typescript-eslint/utils/dist/ts-eslint/Scope.d.ts declare namespace Scope { type ScopeManager = ScopeManager; type Reference = Reference; type Variable = ScopeVariable; type Scope = Scope$1; const ScopeType: typeof ScopeType; type DefinitionType = Definition; type Definition = Definition; const DefinitionType: typeof DefinitionType; namespace Definitions { type CatchClauseDefinition = CatchClauseDefinition; type ClassNameDefinition = ClassNameDefinition; type FunctionNameDefinition = FunctionNameDefinition; type ImplicitGlobalVariableDefinition = ImplicitGlobalVariableDefinition; type ImportBindingDefinition = ImportBindingDefinition; type ParameterDefinition = ParameterDefinition; type TSEnumMemberDefinition = TSEnumMemberDefinition; type TSEnumNameDefinition = TSEnumNameDefinition; type TSModuleNameDefinition = TSModuleNameDefinition; type TypeDefinition = TypeDefinition; type VariableDefinition = VariableDefinition; } namespace Scopes { type BlockScope = BlockScope; type CatchScope = CatchScope; type ClassScope = ClassScope; type ConditionalTypeScope = ConditionalTypeScope; type ForScope = ForScope; type FunctionExpressionNameScope = FunctionExpressionNameScope; type FunctionScope = FunctionScope; type FunctionTypeScope = FunctionTypeScope; type GlobalScope = GlobalScope; type MappedTypeScope = MappedTypeScope; type ModuleScope = ModuleScope; type SwitchScope = SwitchScope; type TSEnumScope = TSEnumScope; type TSModuleScope = TSModuleScope; type TypeScope = TypeScope; type WithScope = WithScope; } } //#endregion //#region node_modules/@typescript-eslint/utils/dist/ts-eslint/Parser.d.ts declare namespace Parser$1 { interface ParserMeta { /** * The unique name of the parser. */ name: string; /** * The a string identifying the version of the parser. */ version?: string; } /** * A loose definition of the ParserModule type for use with configs * This type intended to relax validation of configs so that parsers that have * different AST types or scope managers can still be passed to configs * * @see {@link LooseRuleDefinition}, {@link LooseProcessorModule} */ type LooseParserModule = { /** * Information about the parser to uniquely identify it when serializing. */ meta?: { [K in keyof ParserMeta]?: ParserMeta[K] | undefined }; /** * Parses the given text into an AST */ parseForESLint(text: string, options?: unknown): { [k in keyof ParseResult]: unknown }; } | { /** * Information about the parser to uniquely identify it when serializing. */ meta?: { [K in keyof ParserMeta]?: ParserMeta[K] | undefined }; /** * Parses the given text into an ESTree AST */ parse(text: string, options?: unknown): unknown; }; type ParserModule = { /** * Information about the parser to uniquely identify it when serializing. */ meta?: ParserMeta; /** * Parses the given text into an AST */ parseForESLint(text: string, options?: ParserOptions$1): ParseResult; } | { /** * Information about the parser to uniquely identify it when serializing. */ meta?: ParserMeta; /** * Parses the given text into an ESTree AST */ parse(text: string, options?: ParserOptions$1): Program$2; }; interface ParseResult { /** * The ESTree AST */ ast: Program$2; /** * A `ScopeManager` object. * Custom parsers can use customized scope analysis for experimental/enhancement syntaxes. * The default is the `ScopeManager` object which is created by `eslint-scope`. */ scopeManager?: Scope.ScopeManager; /** * Any parser-dependent services (such as type checkers for nodes). * The value of the services property is available to rules as `context.sourceCode.parserServices`. * The default is an empty object. */ services?: ParserServices; /** * An object to customize AST traversal. * The keys of the object are the type of AST nodes. * Each value is an array of the property names which should be traversed. * The default is `KEYS` of `eslint-visitor-keys`. */ visitorKeys?: VisitorKeys; } interface VisitorKeys { [nodeType: string]: readonly string[]; } } //#endregion //#region node_modules/@typescript-eslint/utils/dist/json-schema.d.ts /** * This is a fork of https://github.com/DefinitelyTyped/DefinitelyTyped/blob/13f63c2eb8d7479caf01ab8d72f9e3683368a8f5/types/json-schema/index.d.ts * We intentionally fork this because: * - ESLint ***ONLY*** supports JSONSchema v4 * - We want to provide stricter types */ /** * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.1 */ type JSONSchema4TypeName = 'any' | 'array' | 'boolean' | 'integer' | 'null' | 'number' | 'object' | 'string'; /** * @see https://tools.ietf.org/html/draft-zyp-json-schema-04#section-3.5 */ type JSONSchema4Type = boolean | number | string | null; type JSONSchema4TypeExtended = JSONSchema4Array | JSONSchema4Object | JSONSchema4Type; interface JSONSchema4Object { [key: string]: JSONSchema4TypeExtended; } interface JSONSchema4Array extends Array {} /** * Meta schema * * Recommended values: * - 'http://json-schema.org/schema#' * - 'http://json-schema.org/hyper-schema#' * - 'http://json-schema.org/draft-04/schema#' * - 'http://json-schema.org/draft-04/hyper-schema#' * - 'http://json-schema.org/draft-03/schema#' * - 'http://json-schema.org/draft-03/hyper-schema#' * * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5 */ type JSONSchema4Version = string; /** * JSON Schema V4 * @see https://tools.ietf.org/html/draft-zyp-json-schema-04 */ type JSONSchema4 = JSONSchema4AllOfSchema | JSONSchema4AnyOfSchema | JSONSchema4AnySchema | JSONSchema4ArraySchema | JSONSchema4BooleanSchema | JSONSchema4MultiSchema | JSONSchema4NullSchema | JSONSchema4NumberSchema | JSONSchema4ObjectSchema | JSONSchema4OneOfSchema | JSONSchema4RefSchema | JSONSchema4StringSchema; interface JSONSchema4Base { /** * Reusable definitions that can be referenced via `$ref` */ $defs?: Record | undefined; /** * Path to a schema defined in `definitions`/`$defs` that will form the base * for this schema. * * If you are defining an "array" schema (`schema: [ ... ]`) for your rule * then you should prefix this with `items/0` so that the validator can find * your definitions. * * eg: `'#/items/0/definitions/myDef'` * * Otherwise if you are defining an "object" schema (`schema: { ... }`) for * your rule you can directly reference your definitions * * eg: `'#/definitions/myDef'` */ $ref?: string | undefined; $schema?: JSONSchema4Version | undefined; /** * (AND) Must be valid against all of the sub-schemas */ allOf?: JSONSchema4[] | undefined; /** * (OR) Must be valid against any of the sub-schemas */ anyOf?: JSONSchema4[] | undefined; /** * The default value for the item if not present */ default?: JSONSchema4TypeExtended | undefined; /** * Reusable definitions that can be referenced via `$ref` */ definitions?: Record | undefined; /** * This attribute is a string that provides a full description of the of * purpose the instance property. * * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.22 */ description?: string | undefined; /** * The value of this property MUST be another schema which will provide * a base schema which the current schema will inherit from. The * inheritance rules are such that any instance that is valid according * to the current schema MUST be valid according to the referenced * schema. This MAY also be an array, in which case, the instance MUST * be valid for all the schemas in the array. A schema that extends * another schema MAY define additional attributes, constrain existing * attributes, or add other constraints. * * Conceptually, the behavior of extends can be seen as validating an * instance against all constraints in the extending schema as well as * the extended schema(s). * * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.26 */ extends?: string | string[] | undefined; id?: string | undefined; /** * (NOT) Must not be valid against the given schema */ not?: JSONSchema4 | undefined; /** * (XOR) Must be valid against exactly one of the sub-schemas */ oneOf?: JSONSchema4[] | undefined; /** * This attribute indicates if the instance must have a value, and not * be undefined. This is false by default, making the instance * optional. * * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.7 */ required?: boolean | string[] | undefined; /** * This attribute is a string that provides a short description of the * instance property. * * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.21 */ title?: string | undefined; /** * A single type, or a union of simple types */ type?: JSONSchema4TypeName | JSONSchema4TypeName[] | undefined; } interface JSONSchema4RefSchema extends JSONSchema4Base { $ref: string; type?: undefined; } interface JSONSchema4AllOfSchema extends JSONSchema4Base { allOf: JSONSchema4[]; type?: undefined; } interface JSONSchema4AnyOfSchema extends JSONSchema4Base { anyOf: JSONSchema4[]; type?: undefined; } interface JSONSchema4OneOfSchema extends JSONSchema4Base { oneOf: JSONSchema4[]; type?: undefined; } interface JSONSchema4MultiSchema extends Omit, Omit, Omit, Omit, Omit, Omit, Omit { /** * This provides an enumeration of all possible values that are valid * for the instance property. This MUST be an array, and each item in * the array represents a possible value for the instance value. If * this attribute is defined, the instance value MUST be one of the * values in the array in order for the schema to be valid. * * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.19 */ enum?: JSONSchema4Type[]; type: JSONSchema4TypeName[]; } /** * @see https://json-schema.org/understanding-json-schema/reference/object.html */ interface JSONSchema4ObjectSchema extends JSONSchema4Base { /** * This attribute defines a schema for all properties that are not * explicitly defined in an object type definition. If specified, the * value MUST be a schema or a boolean. If false is provided, no * additional properties are allowed beyond the properties defined in * the schema. The default value is an empty schema which allows any * value for additional properties. * * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.4 */ additionalProperties?: boolean | JSONSchema4 | undefined; /** * The `dependencies` keyword conditionally applies a sub-schema when a given * property is present. This schema is applied in the same way `allOf` applies * schemas. Nothing is merged or extended. Both schemas apply independently. */ dependencies?: Record | undefined; /** * The maximum number of properties allowed for record-style schemas */ maxProperties?: number | undefined; /** * The minimum number of properties required for record-style schemas */ minProperties?: number | undefined; /** * This attribute is an object that defines the schema for a set of * property names of an object instance. The name of each property of * this attribute's object is a regular expression pattern in the ECMA * 262/Perl 5 format, while the value is a schema. If the pattern * matches the name of a property on the instance object, the value of * the instance's property MUST be valid against the pattern name's * schema value. * * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.3 */ patternProperties?: Record | undefined; /** * This attribute is an object with property definitions that define the * valid values of instance object property values. When the instance * value is an object, the property values of the instance object MUST * conform to the property definitions in this object. In this object, * each property definition's value MUST be a schema, and the property's * name MUST be the name of the instance property that it defines. The * instance property value MUST be valid according to the schema from * the property definition. Properties are considered unordered, the * order of the instance properties MAY be in any order. * * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.2 */ properties?: Record | undefined; type: 'object'; } /** * @see https://json-schema.org/understanding-json-schema/reference/array.html */ interface JSONSchema4ArraySchema extends JSONSchema4Base { /** * May only be defined when "items" is defined, and is a tuple of JSONSchemas. * * This provides a definition for additional items in an array instance * when tuple definitions of the items is provided. This can be false * to indicate additional items in the array are not allowed, or it can * be a schema that defines the schema of the additional items. * * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.6 */ additionalItems?: boolean | JSONSchema4 | undefined; /** * This attribute defines the allowed items in an instance array, and * MUST be a schema or an array of schemas. The default value is an * empty schema which allows any value for items in the instance array. * * When this attribute value is a schema and the instance value is an * array, then all the items in the array MUST be valid according to the * schema. * * When this attribute value is an array of schemas and the instance * value is an array, each position in the instance array MUST conform * to the schema in the corresponding position for this array. This * called tuple typing. When tuple typing is used, additional items are * allowed, disallowed, or constrained by the "additionalItems" * (Section 5.6) attribute using the same rules as * "additionalProperties" (Section 5.4) for objects. * * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.5 */ items?: JSONSchema4 | JSONSchema4[] | undefined; /** * Defines the maximum length of an array */ maxItems?: number | undefined; /** * Defines the minimum length of an array */ minItems?: number | undefined; type: 'array'; /** * Enforces that all items in the array are unique */ uniqueItems?: boolean | undefined; } /** * @see https://json-schema.org/understanding-json-schema/reference/string.html */ interface JSONSchema4StringSchema extends JSONSchema4Base { enum?: string[] | undefined; /** * The `format` keyword allows for basic semantic identification of certain * kinds of string values that are commonly used. * * For example, because JSON doesn’t have a “DateTime” type, dates need to be * encoded as strings. `format` allows the schema author to indicate that the * string value should be interpreted as a date. * * ajv v6 provides a few built-in formats - all other strings will cause AJV * to throw during schema compilation */ format?: 'date' | 'date-time' | 'email' | 'hostname' | 'ipv4' | 'ipv6' | 'json-pointer' | 'json-pointer-uri-fragment' | 'regex' | 'relative-json-pointer' | 'time' | 'uri' | 'uri-reference' | 'uri-template' | 'url' | 'uuid' | undefined; /** * The maximum allowed length for the string */ maxLength?: number | undefined; /** * The minimum allowed length for the string */ minLength?: number | undefined; /** * The `pattern` keyword is used to restrict a string to a particular regular * expression. The regular expression syntax is the one defined in JavaScript * (ECMA 262 specifically) with Unicode support. * * When defining the regular expressions, it’s important to note that the * string is considered valid if the expression matches anywhere within the * string. For example, the regular expression "p" will match any string with * a p in it, such as "apple" not just a string that is simply "p". Therefore, * it is usually less confusing, as a matter of course, to surround the * regular expression in ^...$, for example, "^p$", unless there is a good * reason not to do so. */ pattern?: string | undefined; type: 'string'; } /** * @see https://json-schema.org/understanding-json-schema/reference/numeric.html */ interface JSONSchema4NumberSchema extends JSONSchema4Base { /** * This provides an enumeration of all possible values that are valid * for the instance property. This MUST be an array, and each item in * the array represents a possible value for the instance value. If * this attribute is defined, the instance value MUST be one of the * values in the array in order for the schema to be valid. * * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.19 */ enum?: number[] | undefined; /** * The exclusive minimum allowed value for the number * - `true` = `x < maximum` * - `false` = `x <= maximum` * * Default is `false` */ exclusiveMaximum?: boolean | undefined; /** * Indicates whether or not `minimum` is the inclusive or exclusive minimum * - `true` = `x > minimum` * - `false` = `x ≥ minimum` * * Default is `false` */ exclusiveMinimum?: boolean | undefined; /** * The maximum allowed value for the number */ maximum?: number | undefined; /** * The minimum allowed value for the number */ minimum?: number | undefined; /** * Numbers can be restricted to a multiple of a given number, using the * `multipleOf` keyword. It may be set to any positive number. */ multipleOf?: number | undefined; type: 'integer' | 'number'; } /** * @see https://json-schema.org/understanding-json-schema/reference/boolean.html */ interface JSONSchema4BooleanSchema extends JSONSchema4Base { /** * This provides an enumeration of all possible values that are valid * for the instance property. This MUST be an array, and each item in * the array represents a possible value for the instance value. If * this attribute is defined, the instance value MUST be one of the * values in the array in order for the schema to be valid. * * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.19 */ enum?: boolean[] | undefined; type: 'boolean'; } /** * @see https://json-schema.org/understanding-json-schema/reference/null.html */ interface JSONSchema4NullSchema extends JSONSchema4Base { /** * This provides an enumeration of all possible values that are valid * for the instance property. This MUST be an array, and each item in * the array represents a possible value for the instance value. If * this attribute is defined, the instance value MUST be one of the * values in the array in order for the schema to be valid. * * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.19 */ enum?: null[] | undefined; type: 'null'; } interface JSONSchema4AnySchema extends JSONSchema4Base { type: 'any'; } //#endregion //#region node_modules/@typescript-eslint/utils/dist/ts-eslint/SourceCode.d.ts declare class TokenStore { /** * Checks whether any comments exist or not between the given 2 nodes. * @param left The node to check. * @param right The node to check. * @returns `true` if one or more comments exist. */ commentsExistBetween(left: Node | Token, right: Node | Token): boolean; /** * Gets all comment tokens directly after the given node or token. * @param nodeOrToken The AST node or token to check for adjacent comment tokens. * @returns An array of comments in occurrence order. */ getCommentsAfter(nodeOrToken: Node | Token): Comment[]; /** * Gets all comment tokens directly before the given node or token. * @param nodeOrToken The AST node or token to check for adjacent comment tokens. * @returns An array of comments in occurrence order. */ getCommentsBefore(nodeOrToken: Node | Token): Comment[]; /** * Gets all comment tokens inside the given node. * @param node The AST node to get the comments for. * @returns An array of comments in occurrence order. */ getCommentsInside(node: Node): Comment[]; /** * Gets the first token of the given node. * @param node The AST node. * @param options The option object. If this is a number then it's `options.skip`. If this is a function then it's `options.filter`. * @returns An object representing the token. */ getFirstToken(node: Node, options?: T): SourceCode.ReturnTypeFromOptions | null; /** * Gets the first token between two non-overlapping nodes. * @param left Node before the desired token range. * @param right Node after the desired token range. * @param options The option object. If this is a number then it's `options.skip`. If this is a function then it's `options.filter`. * @returns An object representing the token. */ getFirstTokenBetween(left: Node | Token, right: Node | Token, options?: T): SourceCode.ReturnTypeFromOptions | null; /** * Gets the first `count` tokens of the given node. * @param node The AST node. * @param options The option object. If this is a number then it's `options.count`. If this is a function then it's `options.filter`. */ getFirstTokens(node: Node, options?: T): SourceCode.ReturnTypeFromOptions[]; /** * Gets the first `count` tokens between two non-overlapping nodes. * @param left Node before the desired token range. * @param right Node after the desired token range. * @param options The option object. If this is a number then it's `options.count`. If this is a function then it's `options.filter`. * @returns Tokens between left and right. */ getFirstTokensBetween(left: Node | Token, right: Node | Token, options?: T): SourceCode.ReturnTypeFromOptions[]; /** * Gets the last token of the given node. * @param node The AST node. * @param options The option object. If this is a number then it's `options.skip`. If this is a function then it's `options.filter`. * @returns An object representing the token. */ getLastToken(node: Node, options?: T): SourceCode.ReturnTypeFromOptions | null; /** * Gets the last token between two non-overlapping nodes. * @param left Node before the desired token range. * @param right Node after the desired token range. * @param options The option object. If this is a number then it's `options.skip`. If this is a function then it's `options.filter`. * @returns An object representing the token. */ getLastTokenBetween(left: Node | Token, right: Node | Token, options?: T): SourceCode.ReturnTypeFromOptions | null; /** * Gets the last `count` tokens of the given node. * @param node The AST node. * @param options The option object. If this is a number then it's `options.count`. If this is a function then it's `options.filter`. */ getLastTokens(node: Node, options?: T): SourceCode.ReturnTypeFromOptions[]; /** * Gets the last `count` tokens between two non-overlapping nodes. * @param left Node before the desired token range. * @param right Node after the desired token range. * @param options The option object. If this is a number then it's `options.count`. If this is a function then it's `options.filter`. * @returns Tokens between left and right. */ getLastTokensBetween(left: Node | Token, right: Node | Token, options?: T): SourceCode.ReturnTypeFromOptions[]; /** * Gets the token that follows a given node or token. * @param node The AST node or token. * @param options The option object. If this is a number then it's `options.skip`. If this is a function then it's `options.filter`. * @returns An object representing the token. */ getTokenAfter(node: Node | Token, options?: T): SourceCode.ReturnTypeFromOptions | null; /** * Gets the token that precedes a given node or token. * @param node The AST node or token. * @param options The option object * @returns An object representing the token. */ getTokenBefore(node: Node | Token, options?: T): SourceCode.ReturnTypeFromOptions | null; /** * Gets the token starting at the specified index. * @param offset Index of the start of the token's range. * @param options The option object. If this is a number then it's `options.skip`. If this is a function then it's `options.filter`. * @returns The token starting at index, or null if no such token. */ getTokenByRangeStart(offset: number, options?: T): SourceCode.ReturnTypeFromOptions | null; /** * Gets all tokens that are related to the given node. * @param node The AST node. * @param beforeCount The number of tokens before the node to retrieve. * @param afterCount The number of tokens after the node to retrieve. * @returns Array of objects representing tokens. */ getTokens(node: Node, beforeCount?: number, afterCount?: number): Token[]; /** * Gets all tokens that are related to the given node. * @param node The AST node. * @param options The option object. If this is a function then it's `options.filter`. * @returns Array of objects representing tokens. */ getTokens(node: Node, options: T): SourceCode.ReturnTypeFromOptions[]; /** * Gets the `count` tokens that follows a given node or token. * @param node The AST node. * @param options The option object. If this is a number then it's `options.count`. If this is a function then it's `options.filter`. */ getTokensAfter(node: Node | Token, options?: number | T): SourceCode.ReturnTypeFromOptions[]; /** * Gets the `count` tokens that precedes a given node or token. * @param node The AST node. * @param options The option object. If this is a number then it's `options.count`. If this is a function then it's `options.filter`. */ getTokensBefore(node: Node | Token, options?: number | T): SourceCode.ReturnTypeFromOptions[]; /** * Gets all of the tokens between two non-overlapping nodes. * @param left Node before the desired token range. * @param right Node after the desired token range. * @param options The option object. If this is a number then it's `options.count`. If this is a function then it's `options.filter`. * @returns Tokens between left and right. */ getTokensBetween(left: Node | Token, right: Node | Token, options?: number | T): SourceCode.ReturnTypeFromOptions[]; } declare class SourceCodeBase extends TokenStore { /** * Represents parsed source code. * @param ast The Program node of the AST representing the code. This AST should be created from the text that BOM was stripped. */ constructor(text: string, ast: SourceCode.Program); /** * Represents parsed source code. * @param config The config object. */ constructor(config: SourceCode.SourceCodeConfig); /** * The parsed AST for the source code. */ ast: SourceCode.Program; applyInlineConfig(): void; applyLanguageOptions(): void; finalize(): void; /** * Retrieves an array containing all comments in the source code. * @returns An array of comment nodes. */ getAllComments(): Comment[]; /** * Converts a (line, column) pair into a range index. * @param location A line/column location * @returns The range index of the location in the file. */ getIndexFromLoc(location: Position): number; /** * Gets the entire source text split into an array of lines. * @returns The source text as an array of lines. */ getLines(): string[]; /** * Converts a source text index into a (line, column) pair. * @param index The index of a character in a file * @returns A {line, column} location object with a 0-indexed column */ getLocFromIndex(index: number): Position; /** * Gets the deepest node containing a range index. * @param index Range index of the desired node. * @returns The node if found or `null` if not found. */ getNodeByRangeIndex(index: number): Node | null; /** * Gets the source code for the given node. * @param node The AST node to get the text for. * @param beforeCount The number of characters before the node to retrieve. * @param afterCount The number of characters after the node to retrieve. * @returns The text representing the AST node. */ getText(node?: Node | Token, beforeCount?: number, afterCount?: number): string; /** * The flag to indicate that the source code has Unicode BOM. */ hasBOM: boolean; /** * Determines if two nodes or tokens have at least one whitespace character * between them. Order does not matter. Returns false if the given nodes or * tokens overlap. * @param first The first node or token to check between. * @param second The second node or token to check between. * @returns True if there is a whitespace character between any of the tokens found between the two given nodes or tokens. */ isSpaceBetween(first: Node | Token, second: Node | Token): boolean; /** * Determines if two nodes or tokens have at least one whitespace character * between them. Order does not matter. Returns false if the given nodes or * tokens overlap. * For backward compatibility, this method returns true if there are * `JSXText` tokens that contain whitespace between the two. * @param first The first node or token to check between. * @param second The second node or token to check between. * @returns {boolean} True if there is a whitespace character between * any of the tokens found between the two given nodes or tokens. * @deprecated in favor of isSpaceBetween */ isSpaceBetweenTokens(first: Token, second: Token): boolean; /** * Returns the scope of the given node. * This information can be used track references to variables. */ getScope(node: Node): Scope.Scope; /** * Returns an array of the ancestors of the given node, starting at * the root of the AST and continuing through the direct parent of the current node. * This array does not include the currently-traversed node itself. */ getAncestors(node: Node): Node[]; /** * Returns a list of variables declared by the given node. * This information can be used to track references to variables. */ getDeclaredVariables(node: Node): readonly Scope.Variable[]; /** * Marks a variable with the given name in the current scope as used. * This affects the no-unused-vars rule. */ markVariableAsUsed(name: string, node: Node): boolean; /** * The source code split into lines according to ECMA-262 specification. * This is done to avoid each rule needing to do so separately. */ lines: string[]; /** * The indexes in `text` that each line starts */ lineStartIndices: number[]; /** * The parser services of this source code. */ parserServices?: Partial; /** * The scope of this source code. */ scopeManager: Scope.ScopeManager | null; /** * The original text source code. BOM was stripped from this text. */ text: string; /** * All of the tokens and comments in the AST. * * TODO: rename to 'tokens' */ tokensAndComments: Token[]; /** * The visitor keys to traverse AST. */ visitorKeys: SourceCode.VisitorKeys; /** * Split the source code into multiple lines based on the line delimiters. * @param text Source code as a string. * @returns Array of source code lines. */ static splitLines(text: string): string[]; } declare namespace SourceCode { interface Program extends Program$2 { comments: Comment[]; tokens: Token[]; } interface SourceCodeConfig { /** * The Program node of the AST representing the code. This AST should be created from the text that BOM was stripped. */ ast: Program; /** * The parser services. */ parserServices: ParserServices | null; /** * The scope of this source code. */ scopeManager: Scope.ScopeManager | null; /** * The source code text. */ text: string; /** * The visitor keys to traverse AST. */ visitorKeys: VisitorKeys | null; } type VisitorKeys = Parser$1.VisitorKeys; type FilterPredicate = (token: Token) => boolean; type GetFilterPredicate = Filter extends ((token: Token) => token is infer U extends Token) ? U : Default; type GetFilterPredicateFromOptions = Options extends { filter?: FilterPredicate; } ? GetFilterPredicate : GetFilterPredicate; type ReturnTypeFromOptions = T extends { includeComments: true; } ? GetFilterPredicateFromOptions : GetFilterPredicateFromOptions>; type CursorWithSkipOptions = number | FilterPredicate | { /** * The predicate function to choose tokens. */ filter?: FilterPredicate; /** * The flag to iterate comments as well. */ includeComments?: boolean; /** * The count of tokens the cursor skips. */ skip?: number; }; type CursorWithCountOptions = number | FilterPredicate | { /** * The maximum count of tokens the cursor iterates. */ count?: number; /** * The predicate function to choose tokens. */ filter?: FilterPredicate; /** * The flag to iterate comments as well. */ includeComments?: boolean; }; } declare const SourceCode_base: typeof SourceCodeBase; declare class SourceCode extends SourceCode_base {} //#endregion //#region node_modules/@typescript-eslint/utils/dist/ts-eslint/Rule.d.ts interface RuleMetaDataDocs { /** * Concise description of the rule. */ description: string; /** * The URL of the rule's docs. */ url?: string; /** * Mark this rule as feature-frozen. */ frozen?: boolean; } interface ExternalSpecifier { /** * Name of the referenced plugin / rule. */ name?: string; /** * URL pointing to documentation for the plugin / rule. */ url?: string; } interface ReplacedByInfo { /** * General message presented to the user, e.g. how to replace the rule */ message?: string; /** * URL to more information about this replacement in general */ url?: string; /** * Name should be "eslint" if the replacement is an ESLint core rule. Omit * the property if the replacement is in the same plugin. */ plugin?: ExternalSpecifier; /** * Name and documentation of the replacement rule */ rule?: ExternalSpecifier; } interface DeprecatedInfo { /** * General message presented to the user, e.g. for the key rule why the rule * is deprecated or for info how to replace the rule. */ message?: string; /** * URL to more information about this deprecation in general. */ url?: string; /** * An empty array explicitly states that there is no replacement. */ replacedBy?: ReplacedByInfo[]; /** * The package version since when the rule is deprecated (should use full * semver without a leading "v"). */ deprecatedSince?: string; /** * The estimated version when the rule is removed (probably the next major * version). null means the rule is "frozen" (will be available but will not * be changed). */ availableUntil?: string | null; } interface RuleMetaData { /** * True if the rule is deprecated, false otherwise */ deprecated?: boolean | DeprecatedInfo; /** * Documentation for the rule */ docs?: PluginDocs & RuleMetaDataDocs; /** * The fixer category. Omit if there is no fixer */ fixable?: 'code' | 'whitespace'; /** * Specifies whether rules can return suggestions. Omit if there is no suggestions */ hasSuggestions?: boolean; /** * A map of messages which the rule can report. * The key is the messageId, and the string is the parameterised error string. * See: https://eslint.org/docs/developer-guide/working-with-rules#messageids */ messages: Record; /** * The name of the rule this rule was replaced by, if it was deprecated. * * @deprecated since eslint 9.21.0, in favor of `RuleMetaData#deprecated.replacedBy` */ replacedBy?: readonly string[]; /** * The options schema. Supply an empty array if there are no options. */ schema: JSONSchema4 | readonly JSONSchema4[]; /** * The type of rule. * - `"problem"` means the rule is identifying code that either will cause an error or may cause a confusing behavior. Developers should consider this a high priority to resolve. * - `"suggestion"` means the rule is identifying something that could be done in a better way but no errors will occur if the code isn’t changed. * - `"layout"` means the rule cares primarily about whitespace, semicolons, commas, and parentheses, all the parts of the program that determine how the code looks rather than how it executes. These rules work on parts of the code that aren’t specified in the AST. */ type: 'layout' | 'problem' | 'suggestion'; /** * Specifies default options for the rule. If present, any user-provided options in their config will be merged on top of them recursively. * This merging will be applied directly to `context.options`. * If you want backwards-compatible support for earlier ESLint version, consider using the top-level `defaultOptions` instead. * * since ESLint 9.15.0 */ defaultOptions?: Options; } interface RuleFix { range: Readonly; text: string; } interface RuleFixer { insertTextAfter(nodeOrToken: Node | Token, text: string): RuleFix; insertTextAfterRange(range: Readonly, text: string): RuleFix; insertTextBefore(nodeOrToken: Node | Token, text: string): RuleFix; insertTextBeforeRange(range: Readonly, text: string): RuleFix; remove(nodeOrToken: Node | Token): RuleFix; removeRange(range: Readonly): RuleFix; replaceText(nodeOrToken: Node | Token, text: string): RuleFix; replaceTextRange(range: Readonly, text: string): RuleFix; } interface SuggestionReportDescriptor extends Omit, 'fix'> { readonly fix: ReportFixFunction; } type ReportFixFunction = (fixer: RuleFixer) => IterableIterator | readonly RuleFix[] | RuleFix | null; type ReportSuggestionArray = SuggestionReportDescriptor[]; type ReportDescriptorMessageData = Readonly>; interface ReportDescriptorBase { /** * The parameters for the message string associated with `messageId`. */ readonly data?: ReportDescriptorMessageData; /** * The fixer function. */ readonly fix?: ReportFixFunction | null; /** * The messageId which is being reported. */ readonly messageId: MessageIds; } interface ReportDescriptorWithSuggestion extends ReportDescriptorBase { /** * 6.7's Suggestions API */ readonly suggest?: Readonly> | null; } interface ReportDescriptorNodeOptionalLoc { /** * An override of the location of the report */ readonly loc?: Readonly | Readonly; /** * The Node or AST Token which the report is being attached to */ readonly node: Node | Token; } interface ReportDescriptorLocOnly { /** * An override of the location of the report */ loc: Readonly | Readonly; } type ReportDescriptor = (ReportDescriptorLocOnly | ReportDescriptorNodeOptionalLoc) & ReportDescriptorWithSuggestion; /** * Plugins can add their settings using declaration * merging against this interface. */ interface SharedConfigurationSettings { [name: string]: unknown; } interface RuleContext { /** * The rule ID. */ id: string; /** * The language options configured for this run */ languageOptions: FlatConfig.LanguageOptions & { parserOptions: FlatConfig.ParserOptions; }; /** * An array of the configured options for this rule. * This array does not include the rule severity. */ options: Options; /** * The parser options configured for this run * @deprecated This was deprecated in ESLint 9 and removed in ESLint 10. */ parserOptions: Linter.ParserOptions; /** * The name of the parser from configuration, if in eslintrc (legacy) config. * @deprecated This was deprecated in ESLint 9 and removed in ESLint 10. */ parserPath: string | undefined; /** * An object containing parser-provided services for rules * * @deprecated in favor of `SourceCode#parserServices` */ parserServices?: ParserServices; /** * The shared settings from configuration. * We do not have any shared settings in this plugin. */ settings: SharedConfigurationSettings; /** * Returns an array of the ancestors of the currently-traversed node, starting at * the root of the AST and continuing through the direct parent of the current node. * This array does not include the currently-traversed node itself. * * @deprecated in favor of `SourceCode#getAncestors` */ getAncestors(): Node[]; /** * Returns a list of variables declared by the given node. * This information can be used to track references to variables. * * @deprecated in favor of `SourceCode#getDeclaredVariables` */ getDeclaredVariables(node: Node): readonly Scope.Variable[]; /** * Returns the current working directory passed to Linter. * It is a path to a directory that should be considered as the current working directory. * @deprecated in favor of `RuleContext#cwd` */ getCwd(): string; /** * The current working directory passed to Linter. * It is a path to a directory that should be considered as the current working directory. */ cwd: string; /** * Returns the filename associated with the source. * * @deprecated in favor of `RuleContext#filename` */ getFilename(): string; /** * The filename associated with the source. */ filename: string; /** * Returns the full path of the file on disk without any code block information (unlike `getFilename()`). * @deprecated in favor of `RuleContext#physicalFilename` */ getPhysicalFilename(): string; /** * The full path of the file on disk without any code block information (unlike `filename`). */ physicalFilename: string; /** * Returns the scope of the currently-traversed node. * This information can be used track references to variables. * * @deprecated in favor of `SourceCode#getScope` */ getScope(): Scope.Scope; /** * Returns a SourceCode object that you can use to work with the source that * was passed to ESLint. * * @deprecated in favor of `RuleContext#sourceCode` */ getSourceCode(): Readonly; /** * A SourceCode object that you can use to work with the source that * was passed to ESLint. */ sourceCode: Readonly; /** * Marks a variable with the given name in the current scope as used. * This affects the no-unused-vars rule. * * @deprecated in favor of `SourceCode#markVariableAsUsed` */ markVariableAsUsed(name: string): boolean; /** * Reports a problem in the code. */ report(descriptor: ReportDescriptor): void; } type RuleFunction = (node: T) => void; interface RuleListenerBaseSelectors { AccessorProperty?: RuleFunction; ArrayExpression?: RuleFunction; ArrayPattern?: RuleFunction; ArrowFunctionExpression?: RuleFunction; AssignmentExpression?: RuleFunction; AssignmentPattern?: RuleFunction; AwaitExpression?: RuleFunction; BinaryExpression?: RuleFunction; BlockStatement?: RuleFunction; BreakStatement?: RuleFunction; CallExpression?: RuleFunction; CatchClause?: RuleFunction; ChainExpression?: RuleFunction; ClassBody?: RuleFunction; ClassDeclaration?: RuleFunction; ClassExpression?: RuleFunction; ConditionalExpression?: RuleFunction; ContinueStatement?: RuleFunction; DebuggerStatement?: RuleFunction; Decorator?: RuleFunction; DoWhileStatement?: RuleFunction; EmptyStatement?: RuleFunction; ExportAllDeclaration?: RuleFunction; ExportDefaultDeclaration?: RuleFunction; ExportNamedDeclaration?: RuleFunction; ExportSpecifier?: RuleFunction; ExpressionStatement?: RuleFunction; ForInStatement?: RuleFunction; ForOfStatement?: RuleFunction; ForStatement?: RuleFunction; FunctionDeclaration?: RuleFunction; FunctionExpression?: RuleFunction; Identifier?: RuleFunction; IfStatement?: RuleFunction; ImportAttribute?: RuleFunction; ImportDeclaration?: RuleFunction; ImportDefaultSpecifier?: RuleFunction; ImportExpression?: RuleFunction; ImportNamespaceSpecifier?: RuleFunction; ImportSpecifier?: RuleFunction; JSXAttribute?: RuleFunction; JSXClosingElement?: RuleFunction; JSXClosingFragment?: RuleFunction; JSXElement?: RuleFunction; JSXEmptyExpression?: RuleFunction; JSXExpressionContainer?: RuleFunction; JSXFragment?: RuleFunction; JSXIdentifier?: RuleFunction; JSXMemberExpression?: RuleFunction; JSXNamespacedName?: RuleFunction; JSXOpeningElement?: RuleFunction; JSXOpeningFragment?: RuleFunction; JSXSpreadAttribute?: RuleFunction; JSXSpreadChild?: RuleFunction; JSXText?: RuleFunction; LabeledStatement?: RuleFunction; Literal?: RuleFunction; LogicalExpression?: RuleFunction; MemberExpression?: RuleFunction; MetaProperty?: RuleFunction; MethodDefinition?: RuleFunction; NewExpression?: RuleFunction; ObjectExpression?: RuleFunction; ObjectPattern?: RuleFunction; PrivateIdentifier?: RuleFunction; Program?: RuleFunction; Property?: RuleFunction; PropertyDefinition?: RuleFunction; RestElement?: RuleFunction; ReturnStatement?: RuleFunction; SequenceExpression?: RuleFunction; SpreadElement?: RuleFunction; StaticBlock?: RuleFunction; Super?: RuleFunction; SwitchCase?: RuleFunction; SwitchStatement?: RuleFunction; TaggedTemplateExpression?: RuleFunction; TemplateElement?: RuleFunction; TemplateLiteral?: RuleFunction; ThisExpression?: RuleFunction; ThrowStatement?: RuleFunction; TryStatement?: RuleFunction; TSAbstractAccessorProperty?: RuleFunction; TSAbstractKeyword?: RuleFunction; TSAbstractMethodDefinition?: RuleFunction; TSAbstractPropertyDefinition?: RuleFunction; TSAnyKeyword?: RuleFunction; TSArrayType?: RuleFunction; TSAsExpression?: RuleFunction; TSAsyncKeyword?: RuleFunction; TSBigIntKeyword?: RuleFunction; TSBooleanKeyword?: RuleFunction; TSCallSignatureDeclaration?: RuleFunction; TSClassImplements?: RuleFunction; TSConditionalType?: RuleFunction; TSConstructorType?: RuleFunction; TSConstructSignatureDeclaration?: RuleFunction; TSDeclareFunction?: RuleFunction; TSDeclareKeyword?: RuleFunction; TSEmptyBodyFunctionExpression?: RuleFunction; TSEnumBody?: RuleFunction; TSEnumDeclaration?: RuleFunction; TSEnumMember?: RuleFunction; TSExportAssignment?: RuleFunction; TSExportKeyword?: RuleFunction; TSExternalModuleReference?: RuleFunction; TSFunctionType?: RuleFunction; TSImportEqualsDeclaration?: RuleFunction; TSImportType?: RuleFunction; TSIndexedAccessType?: RuleFunction; TSIndexSignature?: RuleFunction; TSInferType?: RuleFunction; TSInstantiationExpression?: RuleFunction; TSInterfaceBody?: RuleFunction; TSInterfaceDeclaration?: RuleFunction; TSInterfaceHeritage?: RuleFunction; TSIntersectionType?: RuleFunction; TSIntrinsicKeyword?: RuleFunction; TSLiteralType?: RuleFunction; TSMappedType?: RuleFunction; TSMethodSignature?: RuleFunction; TSModuleBlock?: RuleFunction; TSModuleDeclaration?: RuleFunction; TSNamedTupleMember?: RuleFunction; TSNamespaceExportDeclaration?: RuleFunction; TSNeverKeyword?: RuleFunction; TSNonNullExpression?: RuleFunction; TSNullKeyword?: RuleFunction; TSNumberKeyword?: RuleFunction; TSObjectKeyword?: RuleFunction; TSOptionalType?: RuleFunction; TSParameterProperty?: RuleFunction; TSPrivateKeyword?: RuleFunction; TSPropertySignature?: RuleFunction; TSProtectedKeyword?: RuleFunction; TSPublicKeyword?: RuleFunction; TSQualifiedName?: RuleFunction; TSReadonlyKeyword?: RuleFunction; TSRestType?: RuleFunction; TSSatisfiesExpression?: RuleFunction; TSStaticKeyword?: RuleFunction; TSStringKeyword?: RuleFunction; TSSymbolKeyword?: RuleFunction; TSTemplateLiteralType?: RuleFunction; TSThisType?: RuleFunction; TSTupleType?: RuleFunction; TSTypeAliasDeclaration?: RuleFunction; TSTypeAnnotation?: RuleFunction; TSTypeAssertion?: RuleFunction; TSTypeLiteral?: RuleFunction; TSTypeOperator?: RuleFunction; TSTypeParameter?: RuleFunction; TSTypeParameterDeclaration?: RuleFunction; TSTypeParameterInstantiation?: RuleFunction; TSTypePredicate?: RuleFunction; TSTypeQuery?: RuleFunction; TSTypeReference?: RuleFunction; TSUndefinedKeyword?: RuleFunction; TSUnionType?: RuleFunction; TSUnknownKeyword?: RuleFunction; TSVoidKeyword?: RuleFunction; UnaryExpression?: RuleFunction; UpdateExpression?: RuleFunction; VariableDeclaration?: RuleFunction; VariableDeclarator?: RuleFunction; WhileStatement?: RuleFunction; WithStatement?: RuleFunction; YieldExpression?: RuleFunction; } type RuleListenerExitSelectors = { [K in keyof RuleListenerBaseSelectors as `${K}:exit`]: RuleListenerBaseSelectors[K] }; type RuleListenerCatchAllBaseCase = Record; type RuleListener = RuleListenerBaseSelectors & RuleListenerCatchAllBaseCase & RuleListenerExitSelectors; interface RuleModule { /** * Function which returns an object with methods that ESLint calls to “visit” * nodes while traversing the abstract syntax tree. */ create(context: Readonly>): ExtendedRuleListener; /** * @deprecated Use meta.defaultOptions instead * Default options the rule will be run with */ defaultOptions?: Options; /** * Metadata about the rule */ meta: RuleMetaData; /** * Rule name */ name?: string; } type AnyRuleModule = RuleModule; /** * A loose definition of the RuleModule type for use with configs. This type is * intended to relax validation of types so that we can have basic validation * without being overly strict about nitty gritty details matching. * * For example the plugin might be declared using an old version of our types or * they might use the DefinitelyTyped eslint types. Ultimately we don't need * super strict validation in a config - a loose shape match is "good enough" to * help validate the config is correct. * * @see {@link LooseParserModule}, {@link LooseProcessorModule} */ type LooseRuleDefinition = LooseRuleCreateFunction | { create: LooseRuleCreateFunction; meta?: object | undefined; }; type LooseRuleCreateFunction = (context: any) => Record; type RuleCreateFunction = (context: Readonly>) => RuleListener; type AnyRuleCreateFunction = RuleCreateFunction; //#endregion //#region node_modules/@typescript-eslint/utils/dist/ts-eslint/Linter.d.ts type MinimalRuleModule = Partial, 'create'>> & Pick, 'create'>; declare class LinterBase { /** * The version from package.json. */ readonly version: string; /** * Initialize the Linter. * @param config the config object */ constructor(config?: Linter.LinterOptions); /** * Define a new parser module * @param parserId Name of the parser * @param parserModule The parser object */ defineParser(parserId: string, parserModule: Parser$1.LooseParserModule): void; /** * Defines a new linting rule. * @param ruleId A unique rule identifier * @param ruleModule Function from context to object mapping AST node types to event handlers */ defineRule(ruleId: string, ruleModule: MinimalRuleModule | RuleCreateFunction): void; /** * Defines many new linting rules. * @param rulesToDefine map from unique rule identifier to rule */ defineRules(rulesToDefine: Record | RuleCreateFunction>): void; /** * Gets an object with all loaded rules. * @returns All loaded rules */ getRules(): Map>; /** * Gets the `SourceCode` object representing the parsed source. * @returns The `SourceCode` object. */ getSourceCode(): SourceCode; /** * Verifies the text against the rules specified by the second argument. * @param textOrSourceCode The text to parse or a SourceCode object. * @param config An ESLintConfig instance to configure everything. * @param filenameOrOptions The optional filename of the file being checked. * If this is not set, the filename will default to '' in the rule context. * If this is an object, then it has "filename", "allowInlineConfig", and some properties. * @returns The results as an array of messages or an empty array if no messages. */ verify(textOrSourceCode: string | SourceCode, config: Linter.ConfigType, filenameOrOptions?: string | Linter.VerifyOptions): Linter.LintMessage[]; /** * The version from package.json. */ static readonly version: string; /** * Performs multiple autofix passes over the text until as many fixes as possible have been applied. * @param code The source text to apply fixes to. * @param config The ESLint config object to use. * @param options The ESLint options object to use. * @returns The result of the fix operation as returned from the SourceCodeFixer. */ verifyAndFix(code: string, config: Linter.ConfigType, options: Linter.FixOptions): Linter.FixReport; } declare namespace Linter { interface LinterOptions { /** * Which config format to use. * @default 'flat' */ configType?: ConfigTypeSpecifier; /** * path to a directory that should be considered as the current working directory. */ cwd?: string; } type ConfigTypeSpecifier = 'eslintrc' | 'flat'; type EnvironmentConfig = SharedConfig.EnvironmentConfig; type GlobalsConfig = SharedConfig.GlobalsConfig; type GlobalVariableOption = SharedConfig.GlobalVariableOption; type GlobalVariableOptionBase = SharedConfig.GlobalVariableOptionBase; type ParserOptions = SharedConfig.ParserOptions; type PluginMeta = SharedConfig.PluginMeta; type RuleEntry = SharedConfig.RuleEntry; type RuleLevel = SharedConfig.RuleLevel; type RuleLevelAndOptions = SharedConfig.RuleLevelAndOptions; type RulesRecord = SharedConfig.RulesRecord; type Severity = SharedConfig.Severity; type SeverityString = SharedConfig.SeverityString; /** @deprecated use {@link Linter.ConfigType} instead */ type Config = ClassicConfig.Config; type ConfigType = ClassicConfig.Config | FlatConfig.Config | FlatConfig.ConfigArray; /** @deprecated use {@link ClassicConfig.ConfigOverride} instead */ type ConfigOverride = ClassicConfig.ConfigOverride; interface VerifyOptions { /** * Allow/disallow inline comments' ability to change config once it is set. Defaults to true if not supplied. * Useful if you want to validate JS without comments overriding rules. */ allowInlineConfig?: boolean; /** * if `true` then the linter doesn't make `fix` properties into the lint result. */ disableFixes?: boolean; /** * the filename of the source code. */ filename?: string; /** * the predicate function that selects adopt code blocks. */ filterCodeBlock?: (filename: string, text: string) => boolean; /** * postprocessor for report messages. * If provided, this should accept an array of the message lists * for each code block returned from the preprocessor, apply a mapping to * the messages as appropriate, and return a one-dimensional array of * messages. */ postprocess?: Processor$1.PostProcess; /** * preprocessor for source text. * If provided, this should accept a string of source text, and return an array of code blocks to lint. */ preprocess?: Processor$1.PreProcess; /** * Adds reported errors for unused `eslint-disable` directives. */ reportUnusedDisableDirectives?: boolean | SeverityString; } interface FixOptions extends VerifyOptions { /** * Determines whether fixes should be applied. */ fix?: boolean; } interface LintSuggestion { desc: string; fix: RuleFix; messageId?: string; } interface LintMessage { /** * The 1-based column number. */ column: number; /** * The 1-based column number of the end location. */ endColumn?: number; /** * The 1-based line number of the end location. */ endLine?: number; /** * If `true` then this is a fatal error. */ fatal?: true; /** * Information for autofix. */ fix?: RuleFix; /** * The 1-based line number. */ line: number; /** * The error message. */ message: string; messageId?: string; /** * @deprecated `nodeType` is deprecated and will be removed in the next major version. */ nodeType?: string; /** * The ID of the rule which makes this message. */ ruleId: string | null; /** * The severity of this message. */ severity: Severity; source: string | null; /** * Information for suggestions */ suggestions?: LintSuggestion[]; } interface FixReport { /** * True, if the code was fixed */ fixed: boolean; /** * Collection of all messages for the given code */ messages: LintMessage[]; /** * Fixed code text (might be the same as input if no fixes were applied). */ output: string; } /** @deprecated use {@link Parser.ParserModule} */ type ParserModule = Parser$1.LooseParserModule; /** @deprecated use {@link Parser.ParseResult} */ type ESLintParseResult = Parser$1.ParseResult; /** @deprecated use {@link ProcessorType.ProcessorModule} */ type Processor = Processor$1.ProcessorModule; interface Environment { /** * The definition of global variables. */ globals?: GlobalsConfig; /** * The parser options that will be enabled under this environment. */ parserOptions?: ParserOptions; } type LegacyPluginRules = Record; type PluginRules = Record; interface Plugin { /** * The definition of plugin configs. */ configs?: Record; /** * The definition of plugin environments. */ environments?: Record; /** * Metadata about your plugin for easier debugging and more effective caching of plugins. */ meta?: PluginMeta; /** * The definition of plugin processors. */ processors?: Record; /** * The definition of plugin rules. */ rules?: LegacyPluginRules; } } declare const Linter_base: typeof LinterBase; /** * The Linter object does the actual evaluation of the JavaScript code. It doesn't do any filesystem operations, it * simply parses and reports on the code. In particular, the Linter object does not process configuration objects * or files. */ declare class Linter extends Linter_base {} //#endregion //#region node_modules/@typescript-eslint/utils/dist/ts-eslint/Processor.d.ts declare namespace Processor$1 { interface ProcessorMeta { /** * The unique name of the processor. */ name: string; /** * The a string identifying the version of the processor. */ version?: string; } type PreProcess = (text: string, filename: string) => (string | { filename: string; text: string; })[]; type PostProcess = (messagesList: Linter.LintMessage[][], filename: string) => Linter.LintMessage[]; interface ProcessorModule { /** * Information about the processor to uniquely identify it when serializing. */ meta?: ProcessorMeta; /** * The function to merge messages. */ postprocess?: PostProcess; /** * The function to extract code blocks. */ preprocess?: PreProcess; /** * If `true` then it means the processor supports autofix. */ supportsAutofix?: boolean; } /** * A loose definition of the ParserModule type for use with configs * This type intended to relax validation of configs so that parsers that have * different AST types or scope managers can still be passed to configs * * @see {@link LooseRuleDefinition}, {@link LooseParserModule} */ interface LooseProcessorModule { /** * Information about the processor to uniquely identify it when serializing. */ meta?: { [K in keyof ProcessorMeta]?: ProcessorMeta[K] | undefined }; /** * The function to merge messages. */ postprocess?: (messagesList: any, filename: string) => any; /** * The function to extract code blocks. */ preprocess?: (text: string, filename: string) => any; /** * If `true` then it means the processor supports autofix. */ supportsAutofix?: boolean | undefined; } } //#endregion //#region node_modules/@typescript-eslint/utils/dist/ts-eslint/Config.d.ts /** @internal */ declare namespace SharedConfig { type Severity = 0 | 1 | 2; type SeverityString = 'error' | 'off' | 'warn'; type RuleLevel = Severity | SeverityString; type RuleLevelAndOptions = [RuleLevel, ...unknown[]]; type RuleEntry = RuleLevel | RuleLevelAndOptions; type RulesRecord = Partial>; type GlobalVariableOptionBase = 'off' | /** @deprecated use `'readonly'` */'readable' | 'readonly' | 'writable' | /** @deprecated use `'writable'` */'writeable'; type GlobalVariableOptionBoolean = /** @deprecated use `'readonly'` */false | /** @deprecated use `'writable'` */true; type GlobalVariableOption = GlobalVariableOptionBase | GlobalVariableOptionBoolean; interface GlobalsConfig { [name: string]: GlobalVariableOption; } interface EnvironmentConfig { [name: string]: boolean; } type ParserOptions = ParserOptions$1; interface PluginMeta { /** * The meta.name property should match the npm package name for your plugin. */ name: string; /** * If you followed the classic style to name your package * (e.g. `eslint-plugin-X`, `@X/eslint-plugin`, or `@X/eslint-plugin-Y`), * then this should match the classic namespace inferred for your package * (e.g. `X`, `@X`, or `@X/Y`, respectively). */ namespace?: string; /** * The meta.version property should match the npm package version for your plugin. */ version: string; } } declare namespace ClassicConfig { export type EnvironmentConfig = SharedConfig.EnvironmentConfig; export type GlobalsConfig = SharedConfig.GlobalsConfig; export type GlobalVariableOption = SharedConfig.GlobalVariableOption; export type GlobalVariableOptionBase = SharedConfig.GlobalVariableOptionBase; export type ParserOptions = SharedConfig.ParserOptions; export type RuleEntry = SharedConfig.RuleEntry; export type RuleLevel = SharedConfig.RuleLevel; export type RuleLevelAndOptions = SharedConfig.RuleLevelAndOptions; export type RulesRecord = SharedConfig.RulesRecord; export type Severity = SharedConfig.Severity; export type SeverityString = SharedConfig.SeverityString; interface BaseConfig { $schema?: string; /** * The environment settings. */ env?: EnvironmentConfig; /** * The path to other config files or the package name of shareable configs. */ extends?: string | string[]; /** * The global variable settings. */ globals?: GlobalsConfig; /** * The flag that disables comment directives. */ noInlineConfig?: boolean; /** * The override settings per kind of files. */ overrides?: ConfigOverride[]; /** * The path to a parser or the package name of a parser. */ parser?: string | null; /** * The parser options. */ parserOptions?: ParserOptions; /** * The plugin specifiers. */ plugins?: string[]; /** * The processor specifier. */ processor?: string; /** * The flag to report unused `eslint-disable` comments. */ reportUnusedDisableDirectives?: boolean; /** * The rule settings. */ rules?: RulesRecord; /** * The shared settings. */ settings?: SharedConfigurationSettings; } export interface ConfigOverride extends BaseConfig { excludedFiles?: string | string[]; files: string | string[]; } export interface Config extends BaseConfig { /** * The glob patterns that ignore to lint. */ ignorePatterns?: string | string[]; /** * The root flag. */ root?: boolean; } export {}; } declare namespace FlatConfig { type EcmaVersion = EcmaVersion$1; type GlobalsConfig = SharedConfig.GlobalsConfig; type Parser = Parser$1.LooseParserModule; type ParserOptions = SharedConfig.ParserOptions; type PluginMeta = SharedConfig.PluginMeta; type Processor = Processor$1.LooseProcessorModule; type RuleEntry = SharedConfig.RuleEntry; type RuleLevel = SharedConfig.RuleLevel; type RuleLevelAndOptions = SharedConfig.RuleLevelAndOptions; type Rules = SharedConfig.RulesRecord; type Settings = SharedConfigurationSettings; type Severity = SharedConfig.Severity; type SeverityString = SharedConfig.SeverityString; type SourceType = 'commonjs' | SourceType$1; interface SharedConfigs { [key: string]: Config | ConfigArray; } interface Plugin { /** * Shared configurations bundled with the plugin. * Users will reference these directly in their config (i.e. `plugin.configs.recommended`). */ configs?: SharedConfigs; /** * Metadata about your plugin for easier debugging and more effective caching of plugins. */ meta?: { [K in keyof PluginMeta]?: PluginMeta[K] | undefined }; /** * The definition of plugin processors. * Users can stringly reference the processor using the key in their config (i.e., `"pluginName/processorName"`). */ processors?: Partial> | undefined; /** * The definition of plugin rules. * The key must be the name of the rule that users will use * Users can stringly reference the rule using the key they registered the plugin under combined with the rule name. * i.e. for the user config `plugins: { foo: pluginReference }` - the reference would be `"foo/ruleName"`. */ rules?: Record | undefined; } interface Plugins { /** * We intentionally omit the `configs` key from this object because it avoids * type conflicts with old plugins that haven't updated their configs to flat configs yet. * It's valid to reference these old plugins because ESLint won't access the * `.config` property of a plugin when evaluating a flat config. */ [pluginAlias: string]: Omit; } interface LinterOptions { /** * A Boolean value indicating if inline configuration is allowed. */ noInlineConfig?: boolean; /** * A severity string indicating if and how unused disable and enable * directives should be tracked and reported. For legacy compatibility, `true` * is equivalent to `"warn"` and `false` is equivalent to `"off"`. * @default "warn" */ reportUnusedDisableDirectives?: boolean | SharedConfig.Severity | SharedConfig.SeverityString; /** * A severity string indicating if and how unused inline directives * should be tracked and reported. * * since ESLint 9.19.0 * @default "off" */ reportUnusedInlineConfigs?: SharedConfig.Severity | SharedConfig.SeverityString; } interface LanguageOptions { /** * The version of ECMAScript to support. * May be any year (i.e., `2022`) or version (i.e., `5`). * Set to `"latest"` for the most recent supported version. * @default "latest" */ ecmaVersion?: EcmaVersion | undefined; /** * An object specifying additional objects that should be added to the global scope during linting. */ globals?: GlobalsConfig | undefined; /** * An object containing a `parse()` method or a `parseForESLint()` method. * @default * ``` * // https://github.com/eslint/espree * require('espree') * ``` */ parser?: Parser | undefined; /** * An object specifying additional options that are passed directly to the parser. * The available options are parser-dependent. */ parserOptions?: ParserOptions | undefined; /** * The type of JavaScript source code. * Possible values are `"script"` for traditional script files, `"module"` for ECMAScript modules (ESM), and `"commonjs"` for CommonJS files. * @default * ``` * // for `.js` and `.mjs` files * "module" * // for `.cjs` files * "commonjs" * ``` */ sourceType?: SourceType | undefined; } interface Config { /** * The base path for files and ignores. * * Note that this is not permitted inside an `extends` array. * * Since ESLint 9.30.0 */ basePath?: string; /** * An array of glob patterns indicating the files that the configuration object should apply to. * If not specified, the configuration object applies to all files matched by any other configuration object. */ files?: (string | string[])[]; /** * An array of glob patterns indicating the files that the configuration object should not apply to. * If not specified, the configuration object applies to all files matched by files. */ ignores?: string[]; /** * Language specifier in the form `namespace/language-name` where `namespace` is a plugin name set in the `plugins` field. */ language?: string; /** * An object containing settings related to how JavaScript is configured for linting. */ languageOptions?: LanguageOptions; /** * An object containing settings related to the linting process. */ linterOptions?: LinterOptions; /** * An string to identify the configuration object. Used in error messages and inspection tools. */ name?: string; /** * An object containing a name-value mapping of plugin names to plugin objects. * When `files` is specified, these plugins are only available to the matching files. */ plugins?: Plugins; /** * Either an object containing `preprocess()` and `postprocess()` methods or * a string indicating the name of a processor inside of a plugin * (i.e., `"pluginName/processorName"`). */ processor?: string | Processor; /** * An object containing the configured rules. * When `files` or `ignores` are specified, these rule configurations are only available to the matching files. */ rules?: Rules; /** * An object containing name-value pairs of information that should be available to all rules. */ settings?: Settings; } type ConfigArray = Config[]; type ConfigPromise = Promise; type ConfigFile = ConfigArray | ConfigPromise; } //#endregion //#region src/index.d.ts declare const rules: { 'must-use-result': RuleModule<"mustUseResult", [], unknown, RuleListener>; }; declare const _default: ESLint.Plugin; //#endregion export { _default as default, rules };