All Classes Interface Summary Class Summary
| Class |
Description |
| ArrayElement |
An element in an array expression
|
| ArrayElement.Expression |
A regular expression element
|
| ArrayElement.Hole |
An empty slot (elision)
|
| ArrayElement.PartialVisitor<R> |
|
| ArrayElement.Spread |
A spread element ...x
|
| ArrayElement.Visitor<R> |
|
| ArrayTypeExpression |
An array type (T[])
|
| ArrayTypeExpression.Builder |
|
| ArrowFunctionBody |
The body of an arrow function (expression or block)
|
| ArrowFunctionBody.Block |
|
| ArrowFunctionBody.Expression |
|
| ArrowFunctionBody.PartialVisitor<R> |
|
| ArrowFunctionBody.Visitor<R> |
|
| ArrowFunctionExpression |
An arrow function expression
|
| ArrowFunctionExpression.Builder |
|
| AsExpression |
A TypeScript `<expression> as <type>` cast
|
| AsExpression.Builder |
|
| AssignmentExpression |
An assignment expression
|
| AssignmentExpression.Builder |
|
| AssignmentOperator |
An assignment operator
|
| AssignmentOperator.AddAssign |
+=
|
| AssignmentOperator.AndAssign |
&&=
|
| AssignmentOperator.Assign |
=
|
| AssignmentOperator.BitwiseAndAssign |
&=
|
| AssignmentOperator.BitwiseOrAssign |
|=
|
| AssignmentOperator.BitwiseXorAssign |
^=
|
| AssignmentOperator.DivideAssign |
/=
|
| AssignmentOperator.ExponentiateAssign |
**=
|
| AssignmentOperator.LeftShiftAssign |
<<=
|
| AssignmentOperator.ModuloAssign |
%=
|
| AssignmentOperator.MultiplyAssign |
*=
|
| AssignmentOperator.NullishAssign |
??=
|
| AssignmentOperator.OrAssign |
||=
|
| AssignmentOperator.PartialVisitor<R> |
|
| AssignmentOperator.RightShiftAssign |
>>=
|
| AssignmentOperator.SubtractAssign |
-=
|
| AssignmentOperator.UnsignedRightShiftAssign |
>>>=
|
| AssignmentOperator.Visitor<R> |
|
| AssignmentPattern |
A pattern with default value (param = default)
|
| AssignmentPattern.Builder |
|
| BinaryExpression |
A binary operation expression
|
| BinaryExpression.Builder |
|
| BinaryOperator |
A binary operator
|
| BinaryOperator.Add |
+
|
| BinaryOperator.And |
&&
|
| BinaryOperator.BitwiseAnd |
&
|
| BinaryOperator.BitwiseOr |
|
|
| BinaryOperator.BitwiseXor |
^
|
| BinaryOperator.Divide |
/
|
| BinaryOperator.Equal |
==
|
| BinaryOperator.Exponentiate |
**
|
| BinaryOperator.GreaterThan |
>
|
| BinaryOperator.GreaterThanOrEqual |
>=
|
| BinaryOperator.In |
in
|
| BinaryOperator.Instanceof |
instanceof
|
| BinaryOperator.LeftShift |
<<
|
| BinaryOperator.LessThan |
<
|
| BinaryOperator.LessThanOrEqual |
<=
|
| BinaryOperator.Modulo |
%
|
| BinaryOperator.Multiply |
*
|
| BinaryOperator.NotEqual |
!=
|
| BinaryOperator.NullishCoalescing |
??
|
| BinaryOperator.Or |
||
|
| BinaryOperator.PartialVisitor<R> |
|
| BinaryOperator.RightShift |
>>
|
| BinaryOperator.StrictEqual |
===
|
| BinaryOperator.StrictNotEqual |
!==
|
| BinaryOperator.Subtract |
-
|
| BinaryOperator.UnsignedRightShift |
>>>
|
| BinaryOperator.Visitor<R> |
|
| CallExpression |
A function call expression
|
| CallExpression.Builder |
|
| CatchClause |
A catch clause
|
| CatchClause.Builder |
|
| ClassDeclaration |
A class declaration
|
| ClassDeclaration.Builder |
|
| ClassDeclarationWithComments |
A class declaration with optional JSDoc
|
| ClassDeclarationWithComments.Builder |
|
| Coder |
TypeScript code generator: emits TypeScript type declarations from Hydra modules
|
| Comment |
A TypeScript comment
|
| Comment.Block |
A block comment, delimited by slash-star and star-slash
|
| Comment.Documentation |
A documentation comment, delimited by slash-double-star and star-slash (JSDoc)
|
| Comment.Line |
A single-line comment (// ...)
|
| Comment.PartialVisitor<R> |
|
| Comment.Visitor<R> |
|
| ConditionalExpression |
A conditional (ternary) expression: test ? consequent : alternate
|
| ConditionalExpression.Builder |
|
| DocumentationComment |
A documentation comment (JSDoc) with structured tags
|
| DocumentationComment.Builder |
|
| DocumentationTag |
A documentation tag (@param, @returns, @type, etc.)
|
| DocumentationTag.Builder |
|
| DoWhileStatement |
A do-while statement
|
| DoWhileStatement.Builder |
|
| ExportAllDeclaration |
Export all declaration (export * from ...)
|
| ExportAllDeclaration.Builder |
|
| ExportDeclaration |
An export declaration
|
| ExportDeclaration.All |
Export all (export * from ...)
|
| ExportDeclaration.Declaration |
Export a declaration (export const x = ...)
|
| ExportDeclaration.Default |
Default export (export default ...)
|
| ExportDeclaration.Named |
Named exports (export {x, y as z})
|
| ExportDeclaration.PartialVisitor<R> |
|
| ExportDeclaration.Visitor<R> |
|
| ExportSpecifier |
An export specifier (x as y)
|
| ExportSpecifier.Builder |
|
| Expression |
A TypeScript expression
|
| Expression.Array |
An array expression [a, b, c]
|
| Expression.Arrow |
An arrow function expression
|
| Expression.AsExpression |
A TypeScript type assertion `<expr> as <type>`
|
| Expression.Assignment |
An assignment expression
|
| Expression.Await |
An await expression
|
| Expression.Binary |
A binary operation expression
|
| Expression.Call |
A function call expression
|
| Expression.Conditional |
A conditional (ternary) expression
|
| Expression.Function |
A function expression
|
| Expression.Identifier |
A simple identifier
|
| Expression.Literal |
A literal value
|
| Expression.Member |
A member access expression (obj.prop or obj[prop])
|
| Expression.New |
A 'new' expression
|
| Expression.Object_ |
An object expression {a: 1, b: 2}
|
| Expression.Parenthesized |
A parenthesized expression
|
| Expression.PartialVisitor<R> |
|
| Expression.Sequence |
A sequence expression (a, b, c)
|
| Expression.Spread |
A spread expression (...x)
|
| Expression.This |
The 'this' keyword
|
| Expression.Unary |
A unary operation expression
|
| Expression.Visitor<R> |
|
| Expression.Yield |
A yield expression
|
| ForInit |
Initialization clause of a for statement
|
| ForInit.Expression |
|
| ForInit.PartialVisitor<R> |
|
| ForInit.Variable |
|
| ForInit.Visitor<R> |
|
| ForInLeft |
Left-hand side of a for-in or for-of statement
|
| ForInLeft.PartialVisitor<R> |
|
| ForInLeft.Pattern |
|
| ForInLeft.Variable |
|
| ForInLeft.Visitor<R> |
|
| ForInStatement |
A for-in statement
|
| ForInStatement.Builder |
|
| ForOfStatement |
A for-of statement
|
| ForOfStatement.Builder |
|
| ForStatement |
A for statement
|
| ForStatement.Builder |
|
| FunctionDeclaration |
A function declaration
|
| FunctionDeclaration.Builder |
|
| FunctionDeclarationWithComments |
A function declaration with optional JSDoc
|
| FunctionDeclarationWithComments.Builder |
|
| FunctionExpression |
A function expression
|
| FunctionExpression.Builder |
|
| FunctionTypeExpression |
A function type expression
|
| FunctionTypeExpression.Builder |
|
| Identifier |
A TypeScript identifier (variable, function, class name, etc.)
|
| Identifier.Builder |
|
| IfStatement |
An if statement
|
| IfStatement.Builder |
|
| ImportClause |
An import clause (named, default, or namespace import)
|
| ImportClause.Default |
|
| ImportClause.Named |
|
| ImportClause.Namespace |
|
| ImportClause.PartialVisitor<R> |
|
| ImportClause.Visitor<R> |
|
| ImportDeclaration |
An import declaration
|
| ImportDeclaration.Builder |
|
| ImportDefaultSpecifier |
A default import specifier (import x from ...)
|
| ImportDefaultSpecifier.Builder |
|
| ImportNamespaceSpecifier |
A namespace import specifier (import * as x from ...)
|
| ImportNamespaceSpecifier.Builder |
|
| ImportSpecifier |
A named import specifier (import {x as y} from ...)
|
| ImportSpecifier.Builder |
|
| InterfaceDeclaration |
A TypeScript interface declaration (interface Foo<T> extends Bar { ...
|
| InterfaceDeclaration.Builder |
|
| LabeledStatement |
A labeled statement
|
| LabeledStatement.Builder |
|
| Language |
Language constraints and reserved words for TypeScript 5.x (ECMAScript 2024 base)
|
| Literal |
A literal value
|
| Literal.BigInt |
A BigInt literal (e.g., 123n)
|
| Literal.Boolean_ |
A boolean literal (true or false)
|
| Literal.Null |
The null literal
|
| Literal.Number_ |
A numeric literal
|
| Literal.PartialVisitor<R> |
|
| Literal.String_ |
A string literal
|
| Literal.Template |
A template literal
|
| Literal.Undefined |
The undefined literal
|
| Literal.Visitor<R> |
|
| MemberExpression |
A member access expression
|
| MemberExpression.Builder |
|
| MethodDefinition |
A method definition in a class
|
| MethodDefinition.Builder |
|
| MethodKind |
The kind of a class method
|
| MethodKind.Constructor |
|
| MethodKind.Get |
|
| MethodKind.Method |
|
| MethodKind.PartialVisitor<R> |
|
| MethodKind.Set |
|
| MethodKind.Visitor<R> |
|
| ModuleItem |
A top-level item in a module
|
| ModuleItem.Export |
|
| ModuleItem.Import |
|
| ModuleItem.Interface |
A top-level interface declaration
|
| ModuleItem.PartialVisitor<R> |
|
| ModuleItem.Statement |
|
| ModuleItem.TypeAlias |
A top-level type alias declaration
|
| ModuleItem.Visitor<R> |
|
| ModuleItemWithComments |
A module item with optional documentation
|
| ModuleItemWithComments.Builder |
|
| NamedExport |
Named exports (export {x, y as z})
|
| NamedExport.Builder |
|
| NumericLiteral |
A numeric literal (integer or floating-point)
|
| NumericLiteral.Float_ |
A floating-point literal
|
| NumericLiteral.Integer_ |
An integer literal
|
| NumericLiteral.PartialVisitor<R> |
|
| NumericLiteral.Visitor<R> |
|
| ObjectPattern |
An object destructuring pattern {a, b: c}
|
| ObjectPattern.Builder |
|
| ObjectPatternProperty |
A property in an object pattern
|
| ObjectPatternProperty.PartialVisitor<R> |
|
| ObjectPatternProperty.Property |
|
| ObjectPatternProperty.Rest |
|
| ObjectPatternProperty.Visitor<R> |
|
| Operators |
AST operators for TypeScript with precedence and associativity
|
| ParameterizedTypeExpression |
A parameterized type (e.g., Array<T>, Map<K, V>)
|
| ParameterizedTypeExpression.Builder |
|
| Pattern |
A binding pattern (for destructuring)
|
| Pattern.Array |
An array destructuring pattern
|
| Pattern.Assignment |
A pattern with default value
|
| Pattern.Identifier |
A simple identifier binding
|
| Pattern.Object_ |
An object destructuring pattern
|
| Pattern.PartialVisitor<R> |
|
| Pattern.Rest |
A rest element (...x)
|
| Pattern.Typed |
A pattern with a TypeScript type annotation (`x: T`)
|
| Pattern.Visitor<R> |
|
| Program |
A TypeScript program (module)
|
| Program.Builder |
|
| Property |
A property in an object expression
|
| Property.Builder |
|
| PropertyKind |
The kind of an object property
|
| PropertyKind.Get |
A getter
|
| PropertyKind.Init |
A normal property initialization
|
| PropertyKind.PartialVisitor<R> |
|
| PropertyKind.Set |
A setter
|
| PropertyKind.Visitor<R> |
|
| PropertySignature |
A property signature in an object type
|
| PropertySignature.Builder |
|
| RestElement |
A rest element pattern (...x)
|
| RestElement.Builder |
|
| Serde |
Serialization functions for converting TypeScript AST to abstract expressions
|
| SourceType |
Whether the program is a module or script
|
| SourceType.Module |
|
| SourceType.PartialVisitor<R> |
|
| SourceType.Script |
|
| SourceType.Visitor<R> |
|
| SpreadElement |
A spread element (...x)
|
| SpreadElement.Builder |
|
| Statement |
A TypeScript statement
|
| Statement.Block |
A block statement
|
| Statement.Break |
A break statement
|
| Statement.ClassDeclaration |
A class declaration
|
| Statement.Continue |
A continue statement
|
| Statement.Debugger |
A debugger statement
|
| Statement.DoWhile |
A do-while statement
|
| Statement.Empty |
An empty statement (;)
|
| Statement.Expression |
An expression statement
|
| Statement.For |
A for statement
|
| Statement.ForIn |
A for-in statement
|
| Statement.ForOf |
A for-of statement
|
| Statement.FunctionDeclaration |
A function declaration
|
| Statement.If |
An if statement
|
| Statement.Labeled |
A labeled statement
|
| Statement.PartialVisitor<R> |
|
| Statement.Return |
A return statement
|
| Statement.Switch |
A switch statement
|
| Statement.Throw |
A throw statement
|
| Statement.Try |
A try statement
|
| Statement.VariableDeclaration |
A variable declaration
|
| Statement.Visitor<R> |
|
| Statement.While |
A while statement
|
| StatementWithComments |
A statement with optional documentation
|
| StatementWithComments.Builder |
|
| StringLiteral |
A string literal with quote style
|
| StringLiteral.Builder |
|
| SwitchCase |
A case clause in a switch statement
|
| SwitchCase.Builder |
|
| SwitchStatement |
A switch statement
|
| SwitchStatement.Builder |
|
| Syntax |
DSL functions for hydra.typeScript.syntax
|
| TemplateElement |
A static part of a template literal
|
| TemplateElement.Builder |
|
| TemplateLiteral |
A template literal (backtick string with interpolations)
|
| TemplateLiteral.Builder |
|
| ThrowStatement |
A throw statement
|
| ThrowStatement.Builder |
|
| TryStatement |
A try statement
|
| TryStatement.Builder |
|
| TypeAliasDeclaration |
A TypeScript type alias declaration (type Foo<T> = ...)
|
| TypeAliasDeclaration.Builder |
|
| TypeAnnotation |
A type annotation (for JSDoc comments or TypeScript)
|
| TypeAnnotation.Builder |
|
| TypedPattern |
A pattern with a TypeScript type annotation (`x: T`)
|
| TypedPattern.Builder |
|
| TypeExpression |
A type expression
|
| TypeExpression.Any |
The 'any' type
|
| TypeExpression.Array |
An array type
|
| TypeExpression.Function |
A function type
|
| TypeExpression.Identifier |
A named type (e.g., 'string', 'number', 'MyClass')
|
| TypeExpression.Intersection |
An intersection type (A & B)
|
| TypeExpression.Literal |
A literal type (e.g., 'hello', 42)
|
| TypeExpression.Never |
The 'never' type
|
| TypeExpression.Object_ |
An object type
|
| TypeExpression.Optional |
An optional type (T | undefined or T?)
|
| TypeExpression.Parameterized |
A parameterized type (e.g., Array<T>, Map<K, V>)
|
| TypeExpression.PartialVisitor<R> |
|
| TypeExpression.Readonly |
A readonly modifier (readonly T[], readonly [A, B])
|
| TypeExpression.Tuple |
A tuple type (readonly [A, B, C])
|
| TypeExpression.Union |
A union type (A | B)
|
| TypeExpression.Unknown |
The 'unknown' type
|
| TypeExpression.Visitor<R> |
|
| TypeExpression.Void_ |
The 'void' type
|
| TypeParameter |
A type parameter (generic)
|
| TypeParameter.Builder |
|
| UnaryExpression |
A unary operation expression
|
| UnaryExpression.Builder |
|
| UnaryOperator |
A unary operator
|
| UnaryOperator.BitwiseNot |
~
|
| UnaryOperator.Decrement |
--
|
| UnaryOperator.Delete |
delete
|
| UnaryOperator.Increment |
++
|
| UnaryOperator.Negate |
-
|
| UnaryOperator.Not |
!
|
| UnaryOperator.PartialVisitor<R> |
|
| UnaryOperator.Plus |
+
|
| UnaryOperator.Typeof |
typeof
|
| UnaryOperator.Visitor<R> |
|
| UnaryOperator.Void_ |
void
|
| VariableDeclaration |
A variable declaration (var, let, const)
|
| VariableDeclaration.Builder |
|
| VariableDeclarator |
A variable declarator (id = init)
|
| VariableDeclarator.Builder |
|
| VariableKind |
The kind of variable declaration
|
| VariableKind.Const |
|
| VariableKind.Let |
|
| VariableKind.PartialVisitor<R> |
|
| VariableKind.Var |
|
| VariableKind.Visitor<R> |
|
| WhileStatement |
A while statement
|
| WhileStatement.Builder |
|