@typescript-eslint/types 8.0.0-alpha.8 → 8.0.0

package/dist/generated/ast-spec.d.ts

@@ -163,9 +163,6 @@ export declare enum AST_NODE_TYPES {
     WhileStatement = "WhileStatement",
     WithStatement = "WithStatement",
     YieldExpression = "YieldExpression",
-    /**
-     * TS-prefixed nodes
-     */
     TSAbstractAccessorProperty = "TSAbstractAccessorProperty",
     TSAbstractKeyword = "TSAbstractKeyword",
     TSAbstractMethodDefinition = "TSAbstractMethodDefinition",
@@ -330,11 +327,9 @@ export declare interface BreakStatement extends BaseNode {
 }
 export declare interface CallExpression extends BaseNode {
     type: AST_NODE_TYPES.CallExpression;
-    callee: LeftHandSideExpression;
+    callee: Expression;
     arguments: CallExpressionArgument[];
     typeArguments: TSTypeParameterInstantiation | undefined;
-    /** @deprecated Use {@link `typeArguments`} instead. */
-    typeParameters: TSTypeParameterInstantiation | undefined;
     optional: boolean;
 }
 export declare type CallExpressionArgument = Expression | SpreadElement;
@@ -351,8 +346,9 @@ export declare interface ChainExpression extends BaseNode {
 declare interface ClassBase extends BaseNode {
     /**
      * Whether the class is an abstract class.
-     * ```
-     * abstract class Foo {...}
+     * @example
+     * ```ts
+     * abstract class Foo {}
      * ```
      */
     abstract: boolean;
@@ -362,16 +358,18 @@ declare interface ClassBase extends BaseNode {
     body: ClassBody;
     /**
      * Whether the class has been `declare`d:
-     * ```
-     * declare class Foo {...}
+     * @example
+     * ```ts
+     * declare class Foo {}
      * ```
      */
     declare: boolean;
     /**
      * The decorators declared for the class.
-     * ```
+     * @example
+     * ```ts
      * @deco
-     * class Foo {...}
+     * class Foo {}
      * ```
      */
     decorators: Decorator[];
@@ -394,8 +392,6 @@ declare interface ClassBase extends BaseNode {
      * The generic type parameters passed to the superClass.
      */
     superTypeArguments: TSTypeParameterInstantiation | undefined;
-    /** @deprecated Use {@link `superTypeArguments`} instead. */
-    superTypeParameters: TSTypeParameterInstantiation | undefined;
     /**
      * The generic type parameters declared for the class.
      */
@@ -409,9 +405,21 @@ export declare type ClassDeclaration = ClassDeclarationWithName | ClassDeclarati
 declare interface ClassDeclarationBase extends ClassBase {
     type: AST_NODE_TYPES.ClassDeclaration;
 }
+/**
+ * A normal class declaration:
+ * ```
+ * class A {}
+ * ```
+ */
 export declare interface ClassDeclarationWithName extends ClassDeclarationBase {
     id: Identifier;
 }
+/**
+ * Default-exported class declarations have optional names:
+ * ```
+ * export default class {}
+ * ```
+ */
 export declare interface ClassDeclarationWithOptionalName extends ClassDeclarationBase {
     id: Identifier | null;
 }
@@ -420,7 +428,6 @@ export declare interface ClassExpression extends ClassBase {
     type: AST_NODE_TYPES.ClassExpression;
     abstract: false;
     declare: false;
-    decorators: [];
 }
 declare interface ClassMethodDefinitionNonComputedNameBase extends MethodDefinitionBase {
     key: ClassPropertyNameNonComputed;
@@ -445,6 +452,10 @@ export declare interface ContinueStatement extends BaseNode {
 export declare interface DebuggerStatement extends BaseNode {
     type: AST_NODE_TYPES.DebuggerStatement;
 }
+/**
+ * @deprecated
+ * Note that this is neither up to date nor fully correct.
+ */
 export declare type DeclarationStatement = ClassDeclaration | ClassExpression | ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | FunctionDeclaration | TSDeclareFunction | TSEnumDeclaration | TSImportEqualsDeclaration | TSInterfaceDeclaration | TSModuleDeclaration | TSNamespaceExportDeclaration | TSTypeAliasDeclaration;
 export declare interface Decorator extends BaseNode {
     type: AST_NODE_TYPES.Decorator;
@@ -465,21 +476,23 @@ export declare interface ExportAllDeclaration extends BaseNode {
     type: AST_NODE_TYPES.ExportAllDeclaration;
     /**
      * The assertions declared for the export.
+     * @example
+     * ```ts
+     * export * from 'mod' assert \{ type: 'json' \};
      * ```
-     * export * from 'mod' assert { type: 'json' };
-     * ```
-     * @deprecated -- Replaced with {@link `attributes`}.
+     * @deprecated Replaced with {@link `attributes`}.
      */
     assertions: ImportAttribute[];
     /**
      * The attributes declared for the export.
-     * ```
-     * export * from 'mod' assert { type: 'json' };
+     * @example
+     * ```ts
+     * export * from 'mod' with \{ type: 'json' \};
      * ```
      */
     attributes: ImportAttribute[];
     /**
-     * The name for the exported items. `null` if no name is assigned.
+     * The name for the exported items (`as X`). `null` if no name is assigned.
      */
     exported: Identifier | null;
     /**
@@ -500,9 +513,9 @@ export declare interface ExportDefaultDeclaration extends BaseNode {
      */
     declaration: DefaultExportDeclarations;
     /**
-     * The kind of the export.
+     * The kind of the export. Always `value` for default exports.
      */
-    exportKind: ExportKind;
+    exportKind: 'value';
 }
 declare type ExportKind = ExportAndImportKind;
 export declare type ExportNamedDeclaration = ExportNamedDeclarationWithoutSourceWithMultiple | ExportNamedDeclarationWithoutSourceWithSingle | ExportNamedDeclarationWithSource;
@@ -510,8 +523,9 @@ declare interface ExportNamedDeclarationBase extends BaseNode {
     type: AST_NODE_TYPES.ExportNamedDeclaration;
     /**
      * The assertions declared for the export.
-     * ```
-     * export { foo } from 'mod' assert { type: 'json' };
+     * @example
+     * ```ts
+     * export { foo } from 'mod' assert \{ type: 'json' \};
      * ```
      * This will be an empty array if `source` is `null`
      * @deprecated Replaced with {@link `attributes`}.
@@ -519,15 +533,17 @@ declare interface ExportNamedDeclarationBase extends BaseNode {
     assertions: ImportAttribute[];
     /**
      * The attributes declared for the export.
-     * ```
-     * export { foo } from 'mod' assert { type: 'json' };
+     * @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`
@@ -543,13 +559,21 @@ declare interface ExportNamedDeclarationBase extends BaseNode {
     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 };
+ * ```
+ */
 export declare interface ExportNamedDeclarationWithoutSourceWithMultiple extends ExportNamedDeclarationBase {
     /**
      * This will always be an empty array.
@@ -562,8 +586,13 @@ export declare interface ExportNamedDeclarationWithoutSourceWithMultiple extends
     attributes: ImportAttribute[];
     declaration: null;
     source: null;
-    specifiers: ExportSpecifier[];
 }
+/**
+ * Exporting a single named declaration.
+ * ```
+ * export const x = 1;
+ * ```
+ */
 export declare interface ExportNamedDeclarationWithoutSourceWithSingle extends ExportNamedDeclarationBase {
     /**
      * This will always be an empty array.
@@ -576,21 +605,20 @@ export declare interface ExportNamedDeclarationWithoutSourceWithSingle extends E
     attributes: ImportAttribute[];
     declaration: NamedExportDeclarations;
     source: null;
-    specifiers: ExportSpecifier[];
-}
-export declare interface ExportNamedDeclarationWithSource 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[];
+    specifiers: ExportSpecifier[];
+}
+/**
+ * Export names from another module.
+ * ```
+ * export { a, b } from 'mod';
+ * ```
+ */
+export declare interface ExportNamedDeclarationWithSource extends ExportNamedDeclarationBase {
     declaration: null;
     source: StringLiteral;
-    specifiers: ExportSpecifier[];
 }
 export declare interface ExportSpecifier extends BaseNode {
     type: AST_NODE_TYPES.ExportSpecifier;
@@ -630,16 +658,16 @@ declare interface FunctionBase extends BaseNode {
     /**
      * Whether the function is async:
      * ```
-     * async function foo(...) {...}
-     * const x = async function (...) {...}
-     * const x = 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 `FunctionDeclaration` or `FunctionExpression` this is always a `BlockStatement`.
      * - For a `TSDeclareFunction` this is always `undefined`.
      * - For a `TSEmptyBodyFunctionExpression` this is always `null`.
      */
@@ -647,7 +675,7 @@ declare interface FunctionBase extends BaseNode {
     /**
      * This is only `true` if and only if the node is a `TSDeclareFunction` and it has `declare`:
      * ```
-     * declare function foo(...) {...}
+     * declare function foo() {}
      * ```
      */
     declare: boolean;
@@ -662,8 +690,8 @@ declare interface FunctionBase extends BaseNode {
     /**
      * Whether the function is a generator function:
      * ```
-     * function *foo(...) {...}
-     * const x = function *(...) {...}
+     * function *foo() {}
+     * const x = function *() {}
      * ```
      * This is always `false` for arrow functions as they cannot be generators.
      */
@@ -696,9 +724,21 @@ declare interface FunctionDeclarationBase extends FunctionBase {
     declare: false;
     expression: false;
 }
+/**
+ * A normal function declaration:
+ * ```
+ * function f() {}
+ * ```
+ */
 export declare interface FunctionDeclarationWithName extends FunctionDeclarationBase {
     id: Identifier;
 }
+/**
+ * Default-exported function declarations have optional names:
+ * ```
+ * export default function () {}
+ * ```
+ */
 export declare interface FunctionDeclarationWithOptionalName extends FunctionDeclarationBase {
     id: Identifier | null;
 }
@@ -734,16 +774,18 @@ export declare interface ImportDeclaration extends BaseNode {
     type: AST_NODE_TYPES.ImportDeclaration;
     /**
      * The assertions declared for the export.
+     * @example
+     * ```ts
+     * import * from 'mod' assert \{ type: 'json' \};
      * ```
-     * import * from 'mod' assert { type: 'json' };
-     * ```
-     * @deprecated -- Replaced with {@link `attributes`}.
+     * @deprecated Replaced with {@link `attributes`}.
      */
     assertions: ImportAttribute[];
     /**
      * The attributes declared for the export.
-     * ```
-     * import * from 'mod' with { type: 'json' };
+     * @example
+     * ```ts
+     * import * from 'mod' with \{ type: 'json' \};
      * ```
      */
     attributes: ImportAttribute[];
@@ -842,8 +884,6 @@ export declare interface JSXNamespacedName extends BaseNode {
 export declare interface JSXOpeningElement extends BaseNode {
     type: AST_NODE_TYPES.JSXOpeningElement;
     typeArguments: TSTypeParameterInstantiation | undefined;
-    /** @deprecated Use {@link `typeArguments`} instead. */
-    typeParameters: TSTypeParameterInstantiation | undefined;
     selfClosing: boolean;
     name: JSXTagNameExpression;
     attributes: (JSXAttribute | JSXSpreadAttribute)[];
@@ -882,7 +922,8 @@ export declare interface LetOrConstOrVarDeclaration extends BaseNode {
     /**
      * The variables declared by this declaration.
      * Note that there may be 0 declarations (i.e. `const;`).
-     * ```
+     * @example
+     * ```ts
      * let x;
      * let y, z;
      * ```
@@ -890,14 +931,16 @@ export declare interface LetOrConstOrVarDeclaration extends BaseNode {
     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;
@@ -979,11 +1022,9 @@ declare interface MethodDefinitionNonComputedNameBase extends MethodDefinitionBa
 export declare type NamedExportDeclarations = ClassDeclarationWithName | ClassDeclarationWithOptionalName | FunctionDeclarationWithName | FunctionDeclarationWithOptionalName | TSDeclareFunction | TSEnumDeclaration | TSImportEqualsDeclaration | TSInterfaceDeclaration | TSModuleDeclaration | TSTypeAliasDeclaration | VariableDeclaration;
 export declare interface NewExpression extends BaseNode {
     type: AST_NODE_TYPES.NewExpression;
-    callee: LeftHandSideExpression;
+    callee: Expression;
     arguments: CallExpressionArgument[];
     typeArguments: TSTypeParameterInstantiation | undefined;
-    /** @deprecated Use {@link `typeArguments`} instead. */
-    typeParameters: TSTypeParameterInstantiation | undefined;
 }
 export 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 | 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;
 export declare interface NodeOrTokenData {
@@ -991,13 +1032,8 @@ export declare interface NodeOrTokenData {
      * The source location information of the node.
      *
      * The loc property is defined as nullable by ESTree, but ESLint requires this property.
-     *
-     * @see {SourceLocation}
      */
     loc: SourceLocation;
-    /**
-     * @see {Range}
-     */
     range: Range;
     type: string;
 }
@@ -1207,7 +1243,7 @@ export declare interface SpreadElement extends BaseNode {
     type: AST_NODE_TYPES.SpreadElement;
     argument: Expression;
 }
-export declare type Statement = BlockStatement | BreakStatement | ClassDeclarationWithName | ContinueStatement | DebuggerStatement | DoWhileStatement | ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | FunctionDeclarationWithName | IfStatement | ImportDeclaration | LabeledStatement | ReturnStatement | SwitchStatement | ThrowStatement | TryStatement | TSDeclareFunction | TSEnumDeclaration | TSExportAssignment | TSImportEqualsDeclaration | TSInterfaceDeclaration | TSModuleDeclaration | TSNamespaceExportDeclaration | TSTypeAliasDeclaration | VariableDeclaration | WhileStatement | WithStatement;
+export declare type Statement = BlockStatement | BreakStatement | ClassDeclarationWithName | ContinueStatement | DebuggerStatement | DoWhileStatement | EmptyStatement | ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | FunctionDeclarationWithName | IfStatement | ImportDeclaration | LabeledStatement | ReturnStatement | SwitchStatement | ThrowStatement | TryStatement | TSDeclareFunction | TSEnumDeclaration | TSExportAssignment | TSImportEqualsDeclaration | TSInterfaceDeclaration | TSModuleDeclaration | TSNamespaceExportDeclaration | TSTypeAliasDeclaration | VariableDeclaration | WhileStatement | WithStatement;
 export declare interface StaticBlock extends BaseNode {
     type: AST_NODE_TYPES.StaticBlock;
     body: Statement[];
@@ -1232,12 +1268,10 @@ export declare interface SwitchStatement extends BaseNode {
     cases: SwitchCase[];
 }
 export declare interface TaggedTemplateExpression extends BaseNode {
+    quasi: TemplateLiteral;
+    tag: Expression;
     type: AST_NODE_TYPES.TaggedTemplateExpression;
     typeArguments: TSTypeParameterInstantiation | undefined;
-    /** @deprecated Use {@link `typeArguments`} instead. */
-    typeParameters: TSTypeParameterInstantiation | undefined;
-    tag: LeftHandSideExpression;
-    quasi: TemplateLiteral;
 }
 export declare interface TemplateElement extends BaseNode {
     type: AST_NODE_TYPES.TemplateElement;
@@ -1338,12 +1372,52 @@ export declare interface TSConstructorType extends TSFunctionSignatureBase {
 export declare interface TSConstructSignatureDeclaration extends TSFunctionSignatureBase {
     type: AST_NODE_TYPES.TSConstructSignatureDeclaration;
 }
-export declare interface TSDeclareFunction extends FunctionBase {
+export declare type TSDeclareFunction = TSDeclareFunctionNoDeclare | TSDeclareFunctionWithDeclare;
+declare interface TSDeclareFunctionBase extends FunctionBase {
     type: AST_NODE_TYPES.TSDeclareFunction;
-    body: BlockStatement | undefined;
+    /**
+     * 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`)
+ */
+export 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;
+ * ```
+ */
+export 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;
+}
 export declare interface TSDeclareKeyword extends BaseNode {
     type: AST_NODE_TYPES.TSDeclareKeyword;
 }
@@ -1355,7 +1429,6 @@ export declare interface TSEmptyBodyFunctionExpression extends FunctionBase {
 export declare interface TSEnumBody extends BaseNode {
     type: AST_NODE_TYPES.TSEnumBody;
     members: TSEnumMember[];
-    parent: TSEnumDeclaration;
 }
 export declare interface TSEnumDeclaration extends BaseNode {
     type: AST_NODE_TYPES.TSEnumDeclaration;
@@ -1365,15 +1438,17 @@ export declare interface TSEnumDeclaration extends BaseNode {
     body: TSEnumBody;
     /**
      * Whether this is a `const` enum.
-     * ```
-     * const enum Foo {...}
+     * @example
+     * ```ts
+     * const enum Foo {}
      * ```
      */
     const: boolean;
     /**
      * Whether this is a `declare`d enum.
-     * ```
-     * declare enum Foo {...}
+     * @example
+     * ```ts
+     * declare enum Foo {}
      * ```
      */
     declare: boolean;
@@ -1393,18 +1468,20 @@ declare interface TSEnumMemberBase extends BaseNode {
     id: PropertyNameComputed | PropertyNameNonComputed;
     initializer: Expression | undefined;
     computed: boolean;
-    parent: TSEnumBody;
 }
 /**
  * this should only really happen in semantically invalid code (errors 1164 and 2452)
  *
- * VALID:
+ * @example
+ * ```ts
+ * // VALID:
  * enum Foo { ['a'] }
  *
- * INVALID:
+ * // INVALID:
  * const x = 'a';
  * enum Foo { [x] }
  * enum Bar { ['a' + 'b'] }
+ * ```
  */
 export declare interface TSEnumMemberComputedName extends TSEnumMemberBase {
     id: PropertyNameComputed;
@@ -1423,7 +1500,7 @@ export declare interface TSExportKeyword extends BaseNode {
 }
 export declare interface TSExternalModuleReference extends BaseNode {
     type: AST_NODE_TYPES.TSExternalModuleReference;
-    expression: Expression;
+    expression: StringLiteral;
 }
 declare interface TSFunctionSignatureBase extends BaseNode {
     params: Parameter[];
@@ -1436,24 +1513,55 @@ export declare interface TSFunctionType extends TSFunctionSignatureBase {
 declare interface TSHeritageBase extends BaseNode {
     expression: Expression;
     typeArguments: TSTypeParameterInstantiation | undefined;
-    /** @deprecated Use {@link `typeArguments`} instead. */
-    typeParameters: TSTypeParameterInstantiation | undefined;
 }
-export declare interface TSImportEqualsDeclaration extends BaseNode {
+export declare type TSImportEqualsDeclaration = TSImportEqualsNamespaceDeclaration | TSImportEqualsRequireDeclaration;
+declare interface TSImportEqualsDeclarationBase extends BaseNode {
     type: AST_NODE_TYPES.TSImportEqualsDeclaration;
     /**
-     * The locally imported name
+     * The locally imported name.
      */
     id: Identifier;
+    /**
+     * The value being aliased.
+     * @example
+     * ```ts
+     * import F1 = A;
+     * import F2 = A.B.C;
+     * import F3 = require('mod');
+     * ```
+     */
+    moduleReference: Identifier | TSExternalModuleReference | TSQualifiedName;
+    /**
+     * The kind of the import. Always `'value'` unless `moduleReference` is a
+     * `TSExternalModuleReference`.
+     */
+    importKind: ImportKind;
+}
+export declare interface TSImportEqualsNamespaceDeclaration extends TSImportEqualsDeclarationBase {
     /**
      * The value being aliased.
      * ```
      * import F1 = A;
      * import F2 = A.B.C;
+     * ```
+     */
+    moduleReference: Identifier | TSQualifiedName;
+    /**
+     * The kind of the import.
+     */
+    importKind: 'value';
+}
+export declare interface TSImportEqualsRequireDeclaration extends TSImportEqualsDeclarationBase {
+    /**
+     * The value being aliased.
+     * ```
      * import F3 = require('mod');
      * ```
      */
-    moduleReference: EntityName | TSExternalModuleReference;
+    moduleReference: TSExternalModuleReference;
+    /**
+     * The kind of the import.
+     */
     importKind: ImportKind;
 }
 export declare interface TSImportType extends BaseNode {
@@ -1461,8 +1569,6 @@ export declare interface TSImportType extends BaseNode {
     argument: TypeNode;
     qualifier: EntityName | null;
     typeArguments: TSTypeParameterInstantiation | null;
-    /** @deprecated Use {@link `typeArguments`} instead. */
-    typeParameters: TSTypeParameterInstantiation | null;
 }
 export declare interface TSIndexedAccessType extends BaseNode {
     type: AST_NODE_TYPES.TSIndexedAccessType;
@@ -1485,8 +1591,6 @@ export declare interface TSInstantiationExpression extends BaseNode {
     type: AST_NODE_TYPES.TSInstantiationExpression;
     expression: Expression;
     typeArguments: TSTypeParameterInstantiation;
-    /** @deprecated Use {@link `typeArguments`} instead. */
-    typeParameters?: TSTypeParameterInstantiation;
 }
 export declare interface TSInterfaceBody extends BaseNode {
     type: AST_NODE_TYPES.TSInterfaceBody;
@@ -1499,7 +1603,7 @@ export declare interface TSInterfaceDeclaration extends BaseNode {
      */
     body: TSInterfaceBody;
     /**
-     * Whether the interface was `declare`d, `undefined` otherwise
+     * Whether the interface was `declare`d
      */
     declare: boolean;
     /**
@@ -1511,7 +1615,8 @@ export declare interface TSInterfaceDeclaration extends BaseNode {
      */
     id: Identifier;
     /**
-     * The generic type parameters declared for the interface.
+     * The generic type parameters declared for the interface. Empty declaration
+     * (`<>`) is different from no declaration.
      */
     typeParameters: TSTypeParameterDeclaration | undefined;
 }
@@ -1581,60 +1686,86 @@ declare interface TSModuleDeclarationBase extends BaseNode {
     /**
      * The body of the module.
      * This can only be `undefined` for the code `declare module 'mod';`
-     * This will be a `TSModuleDeclaration` if the name is "nested" (`Foo.Bar`).
      */
     body?: TSModuleBlock;
     /**
      * Whether this is a global declaration
-     * ```
+     * @example
+     * ```ts
      * declare global {}
      * ```
+     *
+     * @deprecated Use {@link kind} instead
      */
     global: boolean;
     /**
      * Whether the module is `declare`d
-     * ```
+     * @example
+     * ```ts
      * declare namespace F {}
      * ```
      */
     declare: boolean;
     /**
      * The keyword used to define this module declaration
-     * ```
+     * @example
+     * ```ts
      * namespace Foo {}
      * ^^^^^^^^^
      *
      * module 'foo' {}
      * ^^^^^^
      *
-     * declare global {}
-     *         ^^^^^^
+     * global {}
+     * ^^^^^^
      * ```
      */
     kind: TSModuleDeclarationKind;
 }
 export declare interface TSModuleDeclarationGlobal extends TSModuleDeclarationBase {
     kind: 'global';
-    body: TSModuleBlock;
+    /**
+     * This will always be an Identifier with name `global`
+     */
     id: Identifier;
+    body: TSModuleBlock;
 }
 export declare type TSModuleDeclarationKind = 'global' | 'module' | 'namespace';
 export declare type TSModuleDeclarationModule = TSModuleDeclarationModuleWithIdentifierId | TSModuleDeclarationModuleWithStringId;
 declare interface TSModuleDeclarationModuleBase extends TSModuleDeclarationBase {
     kind: 'module';
 }
+/**
+ * The legacy module declaration, replaced with namespace declarations.
+ * ```
+ * module A {}
+ * ```
+ */
 export declare interface TSModuleDeclarationModuleWithIdentifierId extends TSModuleDeclarationModuleBase {
     kind: 'module';
     id: Identifier;
     body: TSModuleBlock;
 }
 export declare type TSModuleDeclarationModuleWithStringId = TSModuleDeclarationModuleWithStringIdDeclared | TSModuleDeclarationModuleWithStringIdNotDeclared;
+/**
+ * A string module declaration that is declared:
+ * ```
+ * declare module 'foo' {}
+ * declare module 'foo';
+ * ```
+ */
 export declare interface TSModuleDeclarationModuleWithStringIdDeclared extends TSModuleDeclarationModuleBase {
     kind: 'module';
     id: StringLiteral;
     declare: true;
     body?: TSModuleBlock;
 }
+/**
+ * A string module declaration that is not declared:
+ * ```
+ * module 'foo' {}
+ * ```
+ */
 export declare interface TSModuleDeclarationModuleWithStringIdNotDeclared extends TSModuleDeclarationModuleBase {
     kind: 'module';
     id: StringLiteral;
@@ -1652,10 +1783,16 @@ export declare interface TSNamedTupleMember extends BaseNode {
     label: Identifier;
     optional: boolean;
 }
+/**
+ * For the following declaration:
+ * ```
+ * export as namespace X;
+ * ```
+ */
 export declare interface TSNamespaceExportDeclaration extends BaseNode {
     type: AST_NODE_TYPES.TSNamespaceExportDeclaration;
     /**
-     * The name the global variable being exported to
+     * The name of the global variable that's exported as namespace
      */
     id: Identifier;
 }
@@ -1758,7 +1895,8 @@ export declare interface TSTypeAliasDeclaration extends BaseNode {
     type: AST_NODE_TYPES.TSTypeAliasDeclaration;
     /**
      * Whether the type was `declare`d.
-     * ```
+     * @example
+     * ```ts
      * declare type T = 1;
      * ```
      */
@@ -1772,7 +1910,8 @@ export declare interface TSTypeAliasDeclaration extends BaseNode {
      */
     typeAnnotation: TypeNode;
     /**
-     * The generic type parameters declared for the type.
+     * The generic type parameters declared for the type. Empty declaration
+     * (`<>`) is different from no declaration.
      */
     typeParameters: TSTypeParameterDeclaration | undefined;
 }
@@ -1821,14 +1960,10 @@ export declare interface TSTypeQuery extends BaseNode {
     type: AST_NODE_TYPES.TSTypeQuery;
     exprName: EntityName | TSImportType;
     typeArguments: TSTypeParameterInstantiation | undefined;
-    /** @deprecated Use {@link `typeArguments`} instead. */
-    typeParameters: TSTypeParameterInstantiation | undefined;
 }
 export declare interface TSTypeReference extends BaseNode {
     type: AST_NODE_TYPES.TSTypeReference;
     typeArguments: TSTypeParameterInstantiation | undefined;
-    /** @deprecated Use {@link `typeArguments`} instead. */
-    typeParameters: TSTypeParameterInstantiation | undefined;
     typeName: EntityName;
 }
 export declare type TSUnaryExpression = AwaitExpression | LeftHandSideExpression | UnaryExpression | UpdateExpression;
@@ -1854,7 +1989,7 @@ export declare interface UnaryExpression extends UnaryExpressionBase {
 declare interface UnaryExpressionBase extends BaseNode {
     operator: string;
     prefix: boolean;
-    argument: LeftHandSideExpression | Literal | UnaryExpression;
+    argument: Expression;
 }
 export declare interface UpdateExpression extends UnaryExpressionBase {
     type: AST_NODE_TYPES.UpdateExpression;
@@ -1867,7 +2002,8 @@ export declare interface UsingInForOfDeclaration extends BaseNode {
     /**
      * The variables declared by this declaration.
      * Note that there may be 0 declarations (i.e. `const;`).
-     * ```
+     * @example
+     * ```ts
      * for(using x of y){}
      * ```
      */
@@ -1879,7 +2015,8 @@ export declare interface UsingInForOfDeclaration extends BaseNode {
     declare: false;
     /**
      * The keyword used to declare the variable(s)
-     * ```
+     * @example
+     * ```ts
      * for(using x of y){}
      * for(await using x of y){}
      * ```
@@ -1903,7 +2040,8 @@ export declare interface UsingInNormalContextDeclaration extends BaseNode {
     /**
      * The variables declared by this declaration.
      * Note that there may be 0 declarations (i.e. `const;`).
-     * ```
+     * @example
+     * ```ts
      * using x = 1;
      * using y =1, z = 2;
      * ```
@@ -1916,7 +2054,8 @@ export declare interface UsingInNormalContextDeclaration extends BaseNode {
     declare: false;
     /**
      * The keyword used to declare the variable(s)
-     * ```
+     * @example
+     * ```ts
      * using x = 1;
      * await using y = 2;
      * ```