ripple 0.2.183 → 0.2.185

package/src/compiler/types/index.d.ts

@@ -3,6 +3,7 @@ import type * as ESTreeJSX from 'estree-jsx';
 import type { TSESTree } from '@typescript-eslint/types';
 import type { NAMESPACE_URI } from '../../runtime/internal/client/constants.js';
 import type { Parse } from '#parser';
+import type * as ESRap from 'esrap';
 
 export type RpcModules = Map<string, [string, string]>;
 
@@ -61,13 +62,29 @@ declare module 'estree' {
 		metadata: FunctionMetaData;
 	}
 
+	interface MethodDefinition {
+		typeParameters?: TSTypeParameterDeclaration;
+	}
+
+	interface ClassDeclaration {
+		typeParameters?: AST.TSTypeParameterDeclaration;
+		superTypeArguments?: AST.TSTypeParameterInstantiation;
+		implements?: AST.TSClassImplements[];
+	}
+
+	interface ClassExpression {
+		typeParameters?: AST.TSTypeParameterDeclaration;
+		superTypeArguments?: AST.TSTypeParameterInstantiation;
+		implements?: AST.TSClassImplements[];
+	}
+
 	interface Identifier extends TrackedNode {
 		metadata: BaseNode['metadata'] & {
 			tracked_shorthand?: '#Map' | '#Set';
 		};
 	}
 
-	interface MemberExpression extends TrackedNode {}
+	interface MemberExpression extends AST.TrackedNode {}
 
 	interface TrackedNode {
 		tracked?: boolean;
@@ -86,7 +103,7 @@ declare module 'estree' {
 		Attribute: Attribute;
 		RefAttribute: RefAttribute;
 		SpreadAttribute: SpreadAttribute;
-		// Stylesheet: AST.CSS.StyleSheet;
+		ParenthesizedExpression: ParenthesizedExpression;
 	}
 
 	interface ExpressionMap {
@@ -98,6 +115,12 @@ declare module 'estree' {
 		Text: TextNode;
 	}
 
+	// Missing estree type
+	interface ParenthesizedExpression extends AST.BaseNode {
+		type: 'ParenthesizedExpression';
+		expression: AST.Expression;
+	}
+
 	interface Comment {
 		context?: Parse.CommentMetaData | null;
 	}
@@ -105,18 +128,18 @@ declare module 'estree' {
 	/**
 	 * Custom Comment interface with location information
 	 */
-	type CommentWithLocation = Comment & NodeWithLocation;
+	type CommentWithLocation = AST.Comment & NodeWithLocation;
 
 	interface TryStatement {
-		pending?: BlockStatement | null;
+		pending?: AST.BlockStatement | null;
 	}
 
 	interface ForOfStatement {
-		index?: Identifier | null;
-		key?: Expression | null;
+		index?: AST.Identifier | null;
+		key?: AST.Expression | null;
 	}
 
-	interface ServerIdentifier extends BaseNode {
+	interface ServerIdentifier extends AST.BaseNode {
 		type: 'ServerIdentifier';
 	}
 
@@ -154,24 +177,24 @@ declare module 'estree' {
 		// to avoid lots of typecasting or checking for undefined
 		metadata: BaseNodeMetaData;
 
-		comments?: AST.Comment[];
+		comments?: Comment[];
 	}
 
 	interface NodeWithLocation {
 		start: number;
 		end: number;
-		loc: SourceLocation;
+		loc: AST.SourceLocation;
 	}
 
 	/**
 	 * Ripple custom interfaces and types section
 	 */
-	interface Component extends BaseNode {
+	interface Component extends AST.BaseNode {
 		type: 'Component';
 		// null is for anonymous components {component: () => {}}
-		id: Identifier | null;
-		params: Pattern[];
-		body: Node[];
+		id: AST.Identifier | null;
+		params: AST.Pattern[];
+		body: AST.Node[];
 		css: CSS.StyleSheet | null;
 		metadata: BaseNodeMetaData & {
 			inherited_css?: boolean;
@@ -179,7 +202,7 @@ declare module 'estree' {
 		default: boolean;
 	}
 
-	interface TsxCompat extends BaseNode {
+	interface TsxCompat extends AST.BaseNode {
 		type: 'TsxCompat';
 		kind: string;
 		attributes: Array<any>;
@@ -188,19 +211,19 @@ declare module 'estree' {
 		unclosed?: boolean;
 	}
 
-	interface Html extends BaseNode {
+	interface Html extends AST.BaseNode {
 		type: 'Html';
 		expression: Expression;
 	}
 
-	interface Element extends BaseNode {
+	interface Element extends AST.BaseNode {
 		type: 'Element';
-		id: Identifier;
+		id: AST.Identifier;
 		attributes: RippleAttribute[];
-		children: Node[];
+		children: AST.Node[];
 		selfClosing?: boolean;
 		unclosed?: boolean;
-		loc: AST.SourceLocation;
+		loc: SourceLocation;
 		metadata: BaseNodeMetaData & {
 			ts_name?: string;
 		};
@@ -220,11 +243,11 @@ declare module 'estree' {
 
 	export interface TextNode extends AST.BaseNode {
 		type: 'Text';
-		expression: Expression;
-		loc?: SourceLocation;
+		expression: AST.Expression;
+		loc?: AST.SourceLocation;
 	}
 
-	interface ServerBlock extends BaseNode {
+	interface ServerBlock extends AST.BaseNode {
 		type: 'ServerBlock';
 		body: BlockStatement;
 		metadata: BaseNodeMetaData & {
@@ -235,62 +258,62 @@ declare module 'estree' {
 	/**
 	 * Tracked Expressions
 	 */
-	interface TrackedArrayExpression extends Omit<ArrayExpression, 'type'> {
+	interface TrackedArrayExpression extends Omit<AST.ArrayExpression, 'type'> {
 		type: 'TrackedArrayExpression';
-		elements: (Expression | SpreadElement | null)[];
+		elements: (AST.Expression | AST.SpreadElement | null)[];
 	}
 
-	interface TrackedExpression extends BaseNode {
-		argument: Expression;
+	interface TrackedExpression extends AST.BaseNode {
+		argument: AST.Expression;
 		type: 'TrackedExpression';
 	}
 
-	interface TrackedObjectExpression extends Omit<ObjectExpression, 'type'> {
+	interface TrackedObjectExpression extends Omit<AST.ObjectExpression, 'type'> {
 		type: 'TrackedObjectExpression';
-		properties: (Property | SpreadElement)[];
+		properties: (AST.Property | AST.SpreadElement)[];
 	}
 
-	interface TrackedMapExpression extends BaseNode {
+	interface TrackedMapExpression extends AST.BaseNode {
 		type: 'TrackedMapExpression';
-		arguments: (Expression | SpreadElement)[];
+		arguments: (AST.Expression | AST.SpreadElement)[];
 	}
 
-	interface TrackedSetExpression extends BaseNode {
+	interface TrackedSetExpression extends AST.BaseNode {
 		type: 'TrackedSetExpression';
-		arguments: (Expression | SpreadElement)[];
+		arguments: (AST.Expression | AST.SpreadElement)[];
 	}
 
 	/**
 	 * Ripple attribute nodes
 	 */
-	interface Attribute extends BaseNode {
+	interface Attribute extends AST.BaseNode {
 		type: 'Attribute';
-		name: Identifier;
-		value: Expression | null;
-		loc?: SourceLocation;
+		name: AST.Identifier;
+		value: AST.Expression | null;
+		loc?: AST.SourceLocation;
 		shorthand?: boolean;
 		metadata: BaseNodeMetaData & {
 			delegated?: boolean;
 		};
 	}
 
-	interface RefAttribute extends BaseNode {
+	interface RefAttribute extends AST.BaseNode {
 		type: 'RefAttribute';
-		argument: Expression;
-		loc?: SourceLocation;
+		argument: AST.Expression;
+		loc?: AST.SourceLocation;
 	}
 
-	interface SpreadAttribute extends BaseNode {
+	interface SpreadAttribute extends AST.BaseNode {
 		type: 'SpreadAttribute';
-		argument: Expression;
-		loc?: SourceLocation;
+		argument: AST.Expression;
+		loc?: AST.SourceLocation;
 	}
 
 	/**
 	 * Ripple's extended Declaration type that includes Component
-	 * Use this instead of AST.Declaration when you need Component support
+	 * Use this instead of Declaration when you need Component support
 	 */
-	export type RippleDeclaration = AST.Declaration | AST.Component | AST.TSDeclareFunction;
+	export type RippleDeclaration = AST.Declaration | Component | AST.TSDeclareFunction;
 
 	/**
 	 * Ripple's extended ExportNamedDeclaration with Component support
@@ -302,8 +325,8 @@ declare module 'estree' {
 	/**
 	 * Ripple's extended Program with Component support
 	 */
-	interface RippleProgram extends Omit<AST.Program, 'body'> {
-		body: (AST.Program['body'][number] | Component)[];
+	interface RippleProgram extends Omit<Program, 'body'> {
+		body: (Program['body'][number] | Component)[];
 	}
 
 	export type RippleAttribute = Attribute | SpreadAttribute | RefAttribute;
@@ -485,7 +508,7 @@ declare module 'estree-jsx' {
 
 	interface JSXEmptyExpression {
 		loc: AST.SourceLocation;
-		innerComments?: Comment[];
+		innerComments?: AST.Comment[];
 	}
 
 	interface JSXOpeningFragment {
@@ -512,7 +535,9 @@ declare module 'estree-jsx' {
 }
 
 declare module 'estree' {
-	interface NodeMap {
+	// Helper map for creating our own TypeNode
+	// and to be used to extend estree's NodeMap
+	interface TSNodeMap {
 		// TypeScript nodes
 		TSAnyKeyword: TSAnyKeyword;
 		TSArrayType: TSArrayType;
@@ -577,49 +602,196 @@ declare module 'estree' {
 		TSUnknownKeyword: TSUnknownKeyword;
 		TSVoidKeyword: TSVoidKeyword;
 		TSParenthesizedType: TSParenthesizedType;
+		TSExpressionWithTypeArguments: TSExpressionWithTypeArguments;
+		TSClassImplements: TSClassImplements;
 	}
 
+	// Create our version of TypeNode with modified types to be used in replacements
+	type TypeNode = TSNodeMap[keyof TSNodeMap];
+
+	// Extend NodeMap to include TypeScript nodes
+	interface NodeMap extends TSNodeMap {
+		TypeNode: TypeNode;
+	}
+
+	type EntityName = AST.Identifier | AST.ThisExpression | TSQualifiedName;
+	type Parameter =
+		| AST.ArrayPattern
+		| AST.AssignmentPattern
+		| AST.Identifier
+		| AST.ObjectPattern
+		| AST.RestElement
+		| TSParameterProperty;
+	type TypeElement =
+		| TSCallSignatureDeclaration
+		| TSConstructSignatureDeclaration
+		| TSIndexSignature
+		| TSMethodSignature
+		| TSPropertySignature;
+	type TSPropertySignature = TSPropertySignatureComputedName | TSPropertySignatureNonComputedName;
+	type PropertyNameComputed = AST.Expression;
+	type PropertyNameNonComputed = AST.Identifier | NumberLiteral | StringLiteral;
+
 	// TypeScript AST node interfaces from @sveltejs/acorn-typescript
 	// Based on TSESTree types but adapted for acorn's output format
 	interface TSAnyKeyword extends AcornTSNode<TSESTree.TSAnyKeyword> {}
-	interface TSArrayType extends AcornTSNode<TSESTree.TSArrayType> {}
+	interface TSArrayType extends Omit<AcornTSNode<TSESTree.TSArrayType>, 'elementType'> {
+		elementType: TypeNode;
+	}
 	interface TSAsExpression extends AcornTSNode<TSESTree.TSAsExpression> {
 		// Have to override it to use our Expression for required properties like metadata
 		expression: AST.Expression;
 	}
 	interface TSBigIntKeyword extends AcornTSNode<TSESTree.TSBigIntKeyword> {}
 	interface TSBooleanKeyword extends AcornTSNode<TSESTree.TSBooleanKeyword> {}
-	interface TSCallSignatureDeclaration extends AcornTSNode<TSESTree.TSCallSignatureDeclaration> {}
-	interface TSConditionalType extends AcornTSNode<TSESTree.TSConditionalType> {}
-	interface TSConstructorType extends AcornTSNode<TSESTree.TSConstructorType> {}
+	interface TSCallSignatureDeclaration
+		extends Omit<
+			AcornTSNode<TSESTree.TSCallSignatureDeclaration>,
+			'typeParameters' | 'typeAnnotation'
+		> {
+		parameters: Parameter[];
+		typeParameters: TSTypeParameterDeclaration | undefined;
+		typeAnnotation: TSTypeAnnotation | undefined;
+	}
+	interface TSConditionalType
+		extends Omit<
+			AcornTSNode<TSESTree.TSConditionalType>,
+			'checkType' | 'extendsType' | 'falseType' | 'trueType'
+		> {
+		checkType: TypeNode;
+		extendsType: TypeNode;
+		falseType: TypeNode;
+		trueType: TypeNode;
+	}
+	interface TSConstructorType
+		extends Omit<AcornTSNode<TSESTree.TSConstructorType>, 'typeParameters' | 'params'> {
+		typeAnnotation: TSTypeAnnotation | undefined;
+		typeParameters: TSTypeParameterDeclaration | undefined;
+		parameters: AST.Parameter[];
+	}
 	interface TSConstructSignatureDeclaration
-		extends AcornTSNode<TSESTree.TSConstructSignatureDeclaration> {}
-	interface TSDeclareFunction extends AcornTSNode<TSESTree.TSDeclareFunction> {}
-	interface TSEnumDeclaration extends AcornTSNode<TSESTree.TSEnumDeclaration> {}
-	interface TSEnumMember extends AcornTSNode<TSESTree.TSEnumMember> {}
-	interface TSExportAssignment extends AcornTSNode<TSESTree.TSExportAssignment> {}
-	interface TSExternalModuleReference extends AcornTSNode<TSESTree.TSExternalModuleReference> {}
-	interface TSFunctionType extends AcornTSNode<TSESTree.TSFunctionType> {}
+		extends Omit<
+			AcornTSNode<TSESTree.TSConstructSignatureDeclaration>,
+			'typeParameters' | 'typeAnnotation'
+		> {
+		parameters: Parameter[];
+		typeParameters: TSTypeParameterDeclaration | undefined;
+		typeAnnotation: TSTypeAnnotation | undefined;
+	}
+	interface TSDeclareFunction
+		extends Omit<
+			AcornTSNode<TSESTree.TSDeclareFunction>,
+			'id' | 'params' | 'typeParameters' | 'returnType'
+		> {
+		id: AST.Identifier;
+		params: Parameter[];
+		typeParameters: TSTypeParameterDeclaration | undefined;
+		returnType: TSTypeAnnotation | undefined;
+	}
+	interface TSEnumDeclaration
+		extends Omit<AcornTSNode<TSESTree.TSEnumDeclaration>, 'id' | 'members'> {
+		id: AST.Identifier;
+		members: TSEnumMember[];
+	}
+	interface TSEnumMember extends Omit<AcornTSNode<TSESTree.TSEnumMember>, 'id' | 'initializer'> {
+		id: AST.Identifier | StringLiteral;
+		initializer: AST.Expression | undefined;
+	}
+	interface TSExportAssignment
+		extends Omit<AcornTSNode<TSESTree.TSExportAssignment>, 'expression'> {
+		expression: AST.Expression;
+	}
+	interface TSExternalModuleReference
+		extends Omit<AcornTSNode<TSESTree.TSExternalModuleReference>, 'expression'> {
+		expression: StringLiteral;
+	}
+	interface TSFunctionType
+		extends Omit<AcornTSNode<TSESTree.TSFunctionType>, 'typeParameters' | 'params'> {
+		typeAnnotation: TSTypeAnnotation | undefined;
+		typeParameters: TSTypeParameterDeclaration | undefined;
+		parameters: Parameter[];
+	}
 	interface TSImportEqualsDeclaration extends AcornTSNode<TSESTree.TSImportEqualsDeclaration> {}
-	interface TSImportType extends AcornTSNode<TSESTree.TSImportType> {}
-	interface TSIndexedAccessType extends AcornTSNode<TSESTree.TSIndexedAccessType> {}
-	interface TSIndexSignature extends AcornTSNode<TSESTree.TSIndexSignature> {}
-	interface TSInferType extends AcornTSNode<TSESTree.TSInferType> {}
+	interface TSImportType
+		extends Omit<AcornTSNode<TSESTree.TSImportType>, 'argument' | 'qualifier' | 'typeParameters'> {
+		argument: TypeNode;
+		qualifier: EntityName | null;
+		// looks like acorn-typescript has typeParameters
+		typeParameters: TSTypeParameterDeclaration | undefined | undefined;
+	}
+	interface TSIndexedAccessType
+		extends Omit<AcornTSNode<TSESTree.TSIndexedAccessType>, 'indexType' | 'objectType'> {
+		indexType: TypeNode;
+		objectType: TypeNode;
+	}
+	interface TSIndexSignature
+		extends Omit<AcornTSNode<TSESTree.TSIndexSignature>, 'parameters' | 'typeAnnotation'> {
+		parameters: AST.Parameter[];
+		typeAnnotation: TSTypeAnnotation | undefined;
+	}
+	interface TSInferType extends Omit<AcornTSNode<TSESTree.TSInferType>, 'typeParameter'> {
+		typeParameter: TSTypeParameter;
+	}
 	interface TSInstantiationExpression extends AcornTSNode<TSESTree.TSInstantiationExpression> {
 		expression: AST.Expression;
 	}
-	interface TSInterfaceBody extends AcornTSNode<TSESTree.TSInterfaceBody> {}
-	interface TSInterfaceDeclaration extends AcornTSNode<TSESTree.TSInterfaceDeclaration> {}
-	interface TSIntersectionType extends AcornTSNode<TSESTree.TSIntersectionType> {}
+	interface TSInterfaceBody extends Omit<AcornTSNode<TSESTree.TSInterfaceBody>, 'body'> {
+		body: TypeElement[];
+	}
+	interface TSInterfaceDeclaration
+		extends Omit<
+			AcornTSNode<TSESTree.TSInterfaceDeclaration>,
+			'id' | 'typeParameters' | 'body' | 'extends'
+		> {
+		id: AST.Identifier;
+		typeParameters: TSTypeParameterDeclaration | undefined;
+		body: TSInterfaceBody;
+		extends: TSExpressionWithTypeArguments[];
+	}
+	interface TSIntersectionType extends Omit<AcornTSNode<TSESTree.TSIntersectionType>, 'types'> {
+		types: TypeNode[];
+	}
 	interface TSIntrinsicKeyword extends AcornTSNode<TSESTree.TSIntrinsicKeyword> {}
-	interface TSLiteralType extends AcornTSNode<TSESTree.TSLiteralType> {}
-	interface TSMappedType extends AcornTSNode<TSESTree.TSMappedType> {}
-	interface TSMethodSignature extends AcornTSNode<TSESTree.TSMethodSignature> {}
-	interface TSModuleBlock extends AcornTSNode<TSESTree.TSModuleBlock> {}
-	interface TSModuleDeclaration extends AcornTSNode<TSESTree.TSModuleDeclaration> {}
-	interface TSNamedTupleMember extends AcornTSNode<TSESTree.TSNamedTupleMember> {}
+	interface TSLiteralType extends Omit<AcornTSNode<TSESTree.TSLiteralType>, 'literal'> {
+		literal: AST.Literal | AST.TemplateLiteral;
+	}
+	interface TSMappedType
+		extends Omit<
+			AcornTSNode<TSESTree.TSMappedType>,
+			'typeParameter' | 'typeAnnotation' | 'nameType'
+		> {
+		typeAnnotation: TypeNode | undefined;
+		typeParameter: TSTypeParameter;
+		nameType: TypeNode | null;
+	}
+	interface TSMethodSignature
+		extends Omit<
+			AcornTSNode<TSESTree.TSMethodSignature>,
+			'key' | 'typeParameters' | 'params' | 'typeAnnotation'
+		> {
+		key: PropertyNameComputed | PropertyNameNonComputed;
+		typeParameters: TSTypeParameterDeclaration | undefined;
+		parameters: Parameter[];
+		// doesn't actually exist in the spec but acorn-typescript adds it
+		typeAnnotation: TSTypeAnnotation | undefined;
+	}
+	interface TSModuleBlock extends Omit<AcornTSNode<TSESTree.TSModuleBlock>, 'body'> {
+		body: AST.Statement[];
+	}
+	interface TSModuleDeclaration
+		extends Omit<AcornTSNode<TSESTree.TSModuleDeclaration>, 'body' | 'id'> {
+		body: TSModuleBlock;
+		id: AST.Identifier;
+	}
+	interface TSNamedTupleMember
+		extends Omit<AcornTSNode<TSESTree.TSNamedTupleMember>, 'elementType' | 'label'> {
+		elementType: TypeNode;
+		label: AST.Identifier;
+	}
 	interface TSNamespaceExportDeclaration
-		extends AcornTSNode<TSESTree.TSNamespaceExportDeclaration> {}
+		extends Omit<AcornTSNode<TSESTree.TSNamespaceExportDeclaration>, 'id'> {
+		id: AST.Identifier;
+	}
 	interface TSNeverKeyword extends AcornTSNode<TSESTree.TSNeverKeyword> {}
 	interface TSNonNullExpression extends AcornTSNode<TSESTree.TSNonNullExpression> {
 		expression: AST.Expression;
@@ -627,36 +799,107 @@ declare module 'estree' {
 	interface TSNullKeyword extends AcornTSNode<TSESTree.TSNullKeyword> {}
 	interface TSNumberKeyword extends AcornTSNode<TSESTree.TSNumberKeyword> {}
 	interface TSObjectKeyword extends AcornTSNode<TSESTree.TSObjectKeyword> {}
-	interface TSOptionalType extends AcornTSNode<TSESTree.TSOptionalType> {}
+	interface TSOptionalType extends Omit<AcornTSNode<TSESTree.TSOptionalType>, 'typeAnnotation'> {
+		typeAnnotation: TypeNode;
+	}
 	interface TSParameterProperty extends AcornTSNode<TSESTree.TSParameterProperty> {}
-	interface TSPropertySignature extends AcornTSNode<TSESTree.TSPropertySignature> {}
-	interface TSQualifiedName extends AcornTSNode<TSESTree.TSQualifiedName> {}
-	interface TSRestType extends AcornTSNode<TSESTree.TSRestType> {}
+	interface TSPropertySignatureComputedName
+		extends Omit<AcornTSNode<TSESTree.TSPropertySignatureComputedName>, 'key' | 'typeAnnotation'> {
+		key: PropertyNameComputed;
+		typeAnnotation: TSTypeAnnotation | undefined;
+	}
+	interface TSPropertySignatureNonComputedName
+		extends Omit<
+			AcornTSNode<TSESTree.TSPropertySignatureNonComputedName>,
+			'key' | 'typeAnnotation'
+		> {
+		key: PropertyNameNonComputed;
+		typeAnnotation: TSTypeAnnotation | undefined;
+	}
+	interface TSQualifiedName extends Omit<AcornTSNode<TSESTree.TSQualifiedName>, 'left' | 'right'> {
+		left: EntityName;
+		right: AST.Identifier;
+	}
+	interface TSRestType extends Omit<AcornTSNode<TSESTree.TSRestType>, 'typeAnnotation'> {
+		typeAnnotation: TypeNode;
+	}
 	interface TSSatisfiesExpression extends AcornTSNode<TSESTree.TSSatisfiesExpression> {
 		expression: AST.Expression;
 	}
 	interface TSStringKeyword extends AcornTSNode<TSESTree.TSStringKeyword> {}
 	interface TSSymbolKeyword extends AcornTSNode<TSESTree.TSSymbolKeyword> {}
 	interface TSThisType extends AcornTSNode<TSESTree.TSThisType> {}
-	interface TSTupleType extends AcornTSNode<TSESTree.TSTupleType> {}
-	interface TSTypeAliasDeclaration extends AcornTSNode<TSESTree.TSTypeAliasDeclaration> {}
-	interface TSTypeAnnotation extends AcornTSNode<TSESTree.TSTypeAnnotation> {}
+	interface TSTupleType extends Omit<AcornTSNode<TSESTree.TSTupleType>, 'elementTypes'> {
+		elementTypes: TypeNode[];
+	}
+	interface TSTypeAliasDeclaration
+		extends Omit<
+			AcornTSNode<TSESTree.TSTypeAliasDeclaration>,
+			'id' | 'typeParameters' | 'typeAnnotation'
+		> {
+		id: AST.Identifier;
+		typeAnnotation: TypeNode;
+		typeParameters: TSTypeParameterDeclaration | undefined;
+	}
+	interface TSTypeAnnotation
+		extends Omit<AcornTSNode<TSESTree.TSTypeAnnotation>, 'typeAnnotation'> {
+		typeAnnotation: TypeNode;
+	}
 	interface TSTypeAssertion extends AcornTSNode<TSESTree.TSTypeAssertion> {
 		expression: AST.Expression;
 	}
-	interface TSTypeLiteral extends AcornTSNode<TSESTree.TSTypeLiteral> {}
-	interface TSTypeOperator extends AcornTSNode<TSESTree.TSTypeOperator> {}
-	interface TSTypeParameter extends AcornTSNode<TSESTree.TSTypeParameter> {}
-	interface TSTypeParameterDeclaration extends AcornTSNode<TSESTree.TSTypeParameterDeclaration> {}
+	interface TSTypeLiteral extends Omit<AcornTSNode<TSESTree.TSTypeLiteral>, 'members'> {
+		members: TypeElement[];
+	}
+	interface TSTypeOperator extends Omit<AcornTSNode<TSESTree.TSTypeOperator>, 'typeAnnotation'> {
+		typeAnnotation: TypeNode | undefined;
+	}
+	interface TSTypeParameter
+		extends Omit<AcornTSNode<TSESTree.TSTypeParameter>, 'name' | 'constraint' | 'default'> {
+		constraint: TypeNode | undefined;
+		default: TypeNode | undefined;
+		name: AST.Identifier;
+	}
+	interface TSTypeParameterDeclaration
+		extends Omit<AcornTSNode<TSESTree.TSTypeParameterDeclaration>, 'params'> {
+		params: TypeNode[];
+	}
 	interface TSTypeParameterInstantiation
-		extends AcornTSNode<TSESTree.TSTypeParameterInstantiation> {}
+		extends Omit<AcornTSNode<TSESTree.TSTypeParameterInstantiation>, 'params'> {
+		params: TypeNode[];
+	}
 	interface TSTypePredicate extends AcornTSNode<TSESTree.TSTypePredicate> {}
-	interface TSTypeQuery extends AcornTSNode<TSESTree.TSTypeQuery> {}
-	interface TSTypeReference extends AcornTSNode<TSESTree.TSTypeReference> {}
+	interface TSTypeQuery
+		extends Omit<AcornTSNode<TSESTree.TSTypeQuery>, 'exprName' | 'typeArguments'> {
+		exprName: EntityName | TSImportType;
+		typeArguments: TSTypeParameterInstantiation | undefined;
+	}
+	interface TSTypeReference
+		extends Omit<AcornTSNode<TSESTree.TSTypeReference>, 'typeName' | 'typeArguments'> {
+		typeArguments: TSTypeParameterInstantiation | undefined;
+		typeName: EntityName;
+	}
 	interface TSUndefinedKeyword extends AcornTSNode<TSESTree.TSUndefinedKeyword> {}
-	interface TSUnionType extends AcornTSNode<TSESTree.TSUnionType> {}
+	interface TSUnionType extends Omit<AcornTSNode<TSESTree.TSUnionType>, 'types'> {
+		types: TypeNode[];
+	}
+	// TSInterfaceHeritage doesn't exist in acorn-typescript which uses TSExpressionWithTypeArguments
+	interface TSInterfaceHeritage
+		extends Omit<AcornTSNode<TSESTree.TSInterfaceHeritage>, 'expression' | 'typeParameters'> {
+		expression: AST.Expression;
+		// acorn-typescript uses typeParameters instead of typeArguments
+		typeParameters: TSTypeParameterInstantiation | undefined;
+	}
+	// Extends TSInterfaceHeritage as it's the semantically the same as used by acorn-typescript
+	interface TSExpressionWithTypeArguments extends Omit<TSInterfaceHeritage, 'type'> {
+		type: 'TSExpressionWithTypeArguments';
+	}
+
+	interface TSClassImplements extends AcornTSNode<TSESTree.TSClassImplements> {}
 	interface TSUnknownKeyword extends AcornTSNode<TSESTree.TSUnknownKeyword> {}
 	interface TSVoidKeyword extends AcornTSNode<TSESTree.TSVoidKeyword> {}
+	interface NumberLiteral extends AcornTSNode<TSESTree.NumberLiteral> {}
+	interface StringLiteral extends AcornTSNode<TSESTree.StringLiteral> {}
 
 	// acorn-typescript specific nodes (not in @typescript-eslint/types)
 	interface TSParenthesizedType extends AST.BaseNode {
@@ -674,7 +917,6 @@ declare module 'estree' {
 }
 
 import type { Comment, Position } from 'acorn';
-import type { M } from 'vitest/dist/chunks/environment.d.cL3nLXbE.js';
 
 /**
  * Parse error information
@@ -917,7 +1159,8 @@ export type Visitors<T extends AST.Node | AST.CSS.Node, U> = T['type'] extends '
 	? never
 	: SpecializedVisitors<T, U> & { _?: Visitor<T, U, T> };
 
-export interface Context<T, U> {
+export interface Context<T, U>
+	extends Omit<ESRap.Context, 'path' | 'state' | 'visit' | 'next' | 'stop'> {
 	next: (state?: U) => T | void;
 	path: T[];
 	state: U;