@idlizer/arktscgen 2.1.10-arktscgen-4 → 2.1.10-arktscgen-5

package/build/libarkts-copy/src/ts-api/types.ts

@@ -13,10 +13,10 @@
  * limitations under the License.
  */
 
-import * as ts from "@koalaui/ets-tsc"
-import * as arkts from "../arkts-api"
+import * as ts from '@koalaui/ets-tsc';
+import * as arkts from '../arkts-api';
 
-import { throwError } from "../utils"
+import { throwError } from '../utils';
 import {
     passModifiers,
     emptyImplementation,
@@ -24,8 +24,8 @@ import {
     unpackNode,
     unpackNodeArray,
     unpackVariableDeclarationKind,
-} from "./utilities/private"
-import { SyntaxKind } from "./static/enums"
+} from './utilities/private';
+import { SyntaxKind } from './static/enums';
 
 // Improve: write implementation
 export interface TransformationContext {}
@@ -34,84 +34,124 @@ export interface TransformationContext {}
 export interface Program {}
 
 // Improve: remove U type param
-export type NodeArray<T extends Node<U>, U extends arkts.AstNode | undefined = arkts.AstNode | undefined> = ts.NodeArray<T>
+export type NodeArray<
+    T extends Node<U>,
+    U extends arkts.AstNode | undefined = arkts.AstNode | undefined,
+> = ts.NodeArray<T>;
 
 export abstract class Node<T extends arkts.AstNode | undefined = arkts.AstNode | undefined> implements ts.Node {
     constructor(node: T) {
-        this.node = node
+        this.node = node;
     }
 
-    readonly node: T
+    readonly node: T;
 
     // Improve: remove any
     get parent(): any {
         if (this.node === undefined) {
-            throwError('trying to get parent of undefined _node')
+            throwError('trying to get parent of undefined _node');
         }
-        return unpackNode(this.node.parent)
+        return unpackNode(this.node.parent);
     }
 
     set parent(node: Node) {
         if (this.node === undefined) {
-            throwError('trying to set parent of undefined')
+            throwError('trying to set parent of undefined');
         }
         if (node.node === undefined) {
-            throwError('trying to set parent to undefined')
+            throwError('trying to set parent to undefined');
         }
-        this.node.parent = node.node
+        this.node.parent = node.node;
     }
 
     set modifiers(flags: readonly Modifier[] | undefined) {
         if (this.node === undefined) {
-            throwError('trying to set modifiers of undefined')
+            throwError('trying to set modifiers of undefined');
         }
-        this.node.modifiers = passModifiers(flags)
+        this.node.modifiers = passModifiers(flags);
     }
 
     get modifiers(): NodeArray<Modifier> {
-        return unpackModifiers(this.node?.modifiers)
+        return unpackModifiers(this.node?.modifiers);
     }
 
-    abstract kind: SyntaxKind
+    abstract kind: SyntaxKind;
 
     // Improve:
-    forEachChild<T>(cbNode: (node: ts.Node) => T | undefined, cbNodeArray?: ((nodes: ts.NodeArray<ts.Node>) => T | undefined) | undefined): T | undefined { throw new Error("Method not implemented.") }
-    getSourceFile(): ts.SourceFile { throw new Error("Method not implemented.") }
-    getChildCount(sourceFile?: ts.SourceFile | undefined): number { throw new Error("Method not implemented.") }
-    getChildAt(index: number, sourceFile?: ts.SourceFile | undefined): ts.Node { throw new Error("Method not implemented.") }
-    getChildren(sourceFile?: ts.SourceFile | undefined): ts.Node[] { throw new Error("Method not implemented.") }
-
-    getStart(sourceFile?: ts.SourceFile | undefined, includeJsDocComment?: boolean | undefined): number { throw new Error("Method not implemented.") }
-    getFullStart(): number { throw new Error("Method not implemented.") }
-    getEnd(): number { throw new Error("Method not implemented.") }
-    getWidth(sourceFile?: ts.SourceFileLike | undefined): number { throw new Error("Method not implemented.") }
-    getFullWidth(): number { throw new Error("Method not implemented.") }
-    getLeadingTriviaWidth(sourceFile?: ts.SourceFile | undefined): number { throw new Error("Method not implemented.") }
-    getFullText(sourceFile?: ts.SourceFile | undefined): string { throw new Error("Method not implemented.") }
-    getText(sourceFile?: ts.SourceFile | undefined): string { throw new Error("Method not implemented.") }
-    getFirstToken(sourceFile?: ts.SourceFile | undefined): ts.Node | undefined { throw new Error("Method not implemented.") }
-    getLastToken(sourceFile?: ts.SourceFile | undefined): ts.Node | undefined { throw new Error("Method not implemented.") }
-
-    get symbol(): ts.Symbol { return emptyImplementation() }
-    get flags(): ts.NodeFlags { return emptyImplementation() }
-    get pos(): number { return emptyImplementation() }
-    get end(): number { return emptyImplementation() }
+    forEachChild<T>(
+        cbNode: (node: ts.Node) => T | undefined,
+        cbNodeArray?: ((nodes: ts.NodeArray<ts.Node>) => T | undefined) | undefined
+    ): T | undefined {
+        throw new Error('Method not implemented.');
+    }
+    getSourceFile(): ts.SourceFile {
+        throw new Error('Method not implemented.');
+    }
+    getChildCount(sourceFile?: ts.SourceFile | undefined): number {
+        throw new Error('Method not implemented.');
+    }
+    getChildAt(index: number, sourceFile?: ts.SourceFile | undefined): ts.Node {
+        throw new Error('Method not implemented.');
+    }
+    getChildren(sourceFile?: ts.SourceFile | undefined): ts.Node[] {
+        throw new Error('Method not implemented.');
+    }
+
+    getStart(sourceFile?: ts.SourceFile | undefined, includeJsDocComment?: boolean | undefined): number {
+        throw new Error('Method not implemented.');
+    }
+    getFullStart(): number {
+        throw new Error('Method not implemented.');
+    }
+    getEnd(): number {
+        throw new Error('Method not implemented.');
+    }
+    getWidth(sourceFile?: ts.SourceFileLike | undefined): number {
+        throw new Error('Method not implemented.');
+    }
+    getFullWidth(): number {
+        throw new Error('Method not implemented.');
+    }
+    getLeadingTriviaWidth(sourceFile?: ts.SourceFile | undefined): number {
+        throw new Error('Method not implemented.');
+    }
+    getFullText(sourceFile?: ts.SourceFile | undefined): string {
+        throw new Error('Method not implemented.');
+    }
+    getText(sourceFile?: ts.SourceFile | undefined): string {
+        throw new Error('Method not implemented.');
+    }
+    getFirstToken(sourceFile?: ts.SourceFile | undefined): ts.Node | undefined {
+        throw new Error('Method not implemented.');
+    }
+    getLastToken(sourceFile?: ts.SourceFile | undefined): ts.Node | undefined {
+        throw new Error('Method not implemented.');
+    }
+
+    get symbol(): ts.Symbol {
+        return emptyImplementation();
+    }
+    get flags(): ts.NodeFlags {
+        return emptyImplementation();
+    }
+    get pos(): number {
+        return emptyImplementation();
+    }
+    get end(): number {
+        return emptyImplementation();
+    }
 }
 
 // Improve: add all tokens
-export type BinaryOperator =
-    | ts.SyntaxKind.PlusToken
-    | ts.SyntaxKind.MinusToken
-
-    | ts.SyntaxKind.AsteriskToken
+export type BinaryOperator = ts.SyntaxKind.PlusToken | ts.SyntaxKind.MinusToken | ts.SyntaxKind.AsteriskToken;
 
 export type BinaryOperatorToken = Token<BinaryOperator>;
 
 // Improve: rethink maybe (temporary solution)
 export class Token<TKind extends ts.TokenSyntaxKind> extends Node<undefined> {
     constructor(kind: TKind) {
-        super(undefined)
-        this.kind = kind
+        super(undefined);
+        this.kind = kind;
     }
 
     readonly kind: TKind;
@@ -137,272 +177,320 @@ export type ModifierSyntaxKind =
 
 export class Modifier extends Node<undefined> {
     constructor(kind: ModifierSyntaxKind) {
-        super(undefined)
-        this.kind = kind
+        super(undefined);
+        this.kind = kind;
     }
 
     public toString(): string {
-        return `${this.kind}`
+        return `${this.kind}`;
     }
 
-    kind: ModifierSyntaxKind
+    kind: ModifierSyntaxKind;
 }
 
 export abstract class Expression extends Node<arkts.AstNode> implements ts.Expression {
     // Improve: support minimal interface
-    _expressionBrand: any
+    _expressionBrand: any;
 }
 
-export class FunctionDeclaration extends Node<arkts.FunctionDeclaration> implements ts.FunctionDeclaration, FunctionLikeDeclarationBase {
+export class FunctionDeclaration
+    extends Node<arkts.FunctionDeclaration>
+    implements ts.FunctionDeclaration, FunctionLikeDeclarationBase
+{
     constructor(node: arkts.FunctionDeclaration) {
-        super(node)
-        this.name = unpackNode(node.name)
-        this.body = unpackNode(node.body)
-        this.typeParameters = unpackNodeArray(node.typeParamsDecl?.parameters)
-        this.type = unpackNode(node.returnType)
-        this.parameters = unpackNodeArray(node.parameters)
+        super(node);
+        this.name = unpackNode(node.name);
+        this.body = unpackNode(node.body);
+        this.typeParameters = unpackNodeArray(node.typeParamsDecl?.parameters);
+        this.type = unpackNode(node.returnType);
+        this.parameters = unpackNodeArray(node.parameters);
     }
 
-    readonly name?: Identifier | undefined
-    readonly body?: Block | undefined
-    readonly typeParameters?: NodeArray<TypeParameterDeclaration> | undefined
-    readonly type?: TypeNode | undefined
-    readonly parameters: NodeArray<ParameterDeclaration>
-    readonly kind: ts.SyntaxKind.FunctionDeclaration = ts.SyntaxKind.FunctionDeclaration
+    readonly name?: Identifier | undefined;
+    readonly body?: Block | undefined;
+    readonly typeParameters?: NodeArray<TypeParameterDeclaration> | undefined;
+    readonly type?: TypeNode | undefined;
+    readonly parameters: NodeArray<ParameterDeclaration>;
+    readonly kind: ts.SyntaxKind.FunctionDeclaration = ts.SyntaxKind.FunctionDeclaration;
 
     // brands
-    _functionLikeDeclarationBrand: any
-    _declarationBrand: any
-    _statementBrand: any
+    _functionLikeDeclarationBrand: any;
+    _declarationBrand: any;
+    _statementBrand: any;
 }
 
-export class FunctionExpression extends Node<arkts.FunctionExpression> implements ts.FunctionExpression, FunctionLikeDeclarationBase {
+export class FunctionExpression
+    extends Node<arkts.FunctionExpression>
+    implements ts.FunctionExpression, FunctionLikeDeclarationBase
+{
     constructor(node: arkts.FunctionExpression) {
-        super(node)
-        this.name = unpackNode(node.scriptFunction.ident)
+        super(node);
+        this.name = unpackNode(node.scriptFunction.ident);
         if (node.scriptFunction.body === undefined) {
-            throwError('body expected to be not undefined')
+            throwError('body expected to be not undefined');
         }
-        this.body = unpackNode(node.scriptFunction.body)
-        this.parameters = unpackNodeArray(node.scriptFunction.parameters)
+        this.body = unpackNode(node.scriptFunction.body);
+        this.parameters = unpackNodeArray(node.scriptFunction.parameters);
     }
 
-    readonly name?: Identifier
-    readonly body: Block
-    readonly parameters: NodeArray<ParameterDeclaration>
-    readonly kind: ts.SyntaxKind.FunctionExpression = ts.SyntaxKind.FunctionExpression
+    readonly name?: Identifier;
+    readonly body: Block;
+    readonly parameters: NodeArray<ParameterDeclaration>;
+    readonly kind: ts.SyntaxKind.FunctionExpression = ts.SyntaxKind.FunctionExpression;
 
     // brands
-    _primaryExpressionBrand: any
-    _memberExpressionBrand: any
-    _leftHandSideExpressionBrand: any
-    _updateExpressionBrand: any
-    _unaryExpressionBrand: any
-    _expressionBrand: any
-    _functionLikeDeclarationBrand: any
-    _declarationBrand: any
+    _primaryExpressionBrand: any;
+    _memberExpressionBrand: any;
+    _leftHandSideExpressionBrand: any;
+    _updateExpressionBrand: any;
+    _unaryExpressionBrand: any;
+    _expressionBrand: any;
+    _functionLikeDeclarationBrand: any;
+    _declarationBrand: any;
 }
 
 export class Identifier extends Node<arkts.Identifier> implements ts.Identifier, Expression {
     constructor(node: arkts.Identifier) {
-        super(node)
-        this.text = node.name
+        super(node);
+        this.text = node.name;
     }
 
-    readonly text: string
-    readonly kind: ts.SyntaxKind.Identifier = ts.SyntaxKind.Identifier
+    readonly text: string;
+    readonly kind: ts.SyntaxKind.Identifier = ts.SyntaxKind.Identifier;
 
     // Improve:
-    get escapedText(): ts.__String { return emptyImplementation() }
+    get escapedText(): ts.__String {
+        return emptyImplementation();
+    }
 
     // brands
-    _primaryExpressionBrand: any
-    _memberExpressionBrand: any
-    _leftHandSideExpressionBrand: any
-    _updateExpressionBrand: any
-    _unaryExpressionBrand: any
-    _expressionBrand: any
-    _declarationBrand: any
+    _primaryExpressionBrand: any;
+    _memberExpressionBrand: any;
+    _leftHandSideExpressionBrand: any;
+    _updateExpressionBrand: any;
+    _unaryExpressionBrand: any;
+    _expressionBrand: any;
+    _declarationBrand: any;
 }
 
 export class PrivateIdentifier extends Node<arkts.Identifier> implements ts.PrivateIdentifier, Expression {
     constructor(node: arkts.Identifier) {
-        super(node)
-        this.text = node.name
+        super(node);
+        this.text = node.name;
         if (!node.isPrivate) {
-            throwError('identifier expected to be private')
+            throwError('identifier expected to be private');
         }
     }
 
-    readonly text: string
-    readonly kind: ts.SyntaxKind.PrivateIdentifier = ts.SyntaxKind.PrivateIdentifier
+    readonly text: string;
+    readonly kind: ts.SyntaxKind.PrivateIdentifier = ts.SyntaxKind.PrivateIdentifier;
 
     // Improve:
-    get escapedText(): ts.__String { return emptyImplementation() }
+    get escapedText(): ts.__String {
+        return emptyImplementation();
+    }
 
     // brands
-    _primaryExpressionBrand: any
-    _memberExpressionBrand: any
-    _leftHandSideExpressionBrand: any
-    _updateExpressionBrand: any
-    _unaryExpressionBrand: any
-    _expressionBrand: any
-    _declarationBrand: any
+    _primaryExpressionBrand: any;
+    _memberExpressionBrand: any;
+    _leftHandSideExpressionBrand: any;
+    _updateExpressionBrand: any;
+    _unaryExpressionBrand: any;
+    _expressionBrand: any;
+    _declarationBrand: any;
 }
 
 export abstract class Statement extends Node<arkts.AstNode> implements ts.Statement {
     // brands
-    _statementBrand: any
+    _statementBrand: any;
 }
 
 export class Block extends Node<arkts.BlockStatement> implements ts.Block {
     constructor(node: arkts.BlockStatement) {
-        super(node)
-        this.statements = unpackNodeArray(node.statements)
+        super(node);
+        this.statements = unpackNodeArray(node.statements);
     }
 
-    readonly statements: NodeArray<Statement>
-    readonly kind: ts.SyntaxKind.Block = ts.SyntaxKind.Block
+    readonly statements: NodeArray<Statement>;
+    readonly kind: ts.SyntaxKind.Block = ts.SyntaxKind.Block;
 
     // brands
-    _statementBrand: any
+    _statementBrand: any;
 }
 
 export class SourceFile extends Node<arkts.EtsScript> implements ts.SourceFile {
     constructor(node: arkts.EtsScript) {
-        super(node)
+        super(node);
 
-        this.statements = unpackNodeArray(this.node.statements)
+        this.statements = unpackNodeArray(this.node.statements);
     }
 
-    readonly statements: NodeArray<Statement>
-    readonly kind: ts.SyntaxKind.SourceFile = ts.SyntaxKind.SourceFile
+    readonly statements: NodeArray<Statement>;
+    readonly kind: ts.SyntaxKind.SourceFile = ts.SyntaxKind.SourceFile;
 
     // Improve:
-    getLineAndCharacterOfPosition(pos: number): ts.LineAndCharacter { throw new Error("Method not implemented.") }
-    getLineEndOfPosition(pos: number): number { throw new Error("Method not implemented.") }
-    getLineStarts(): readonly number[] { throw new Error("Method not implemented.") }
-    getPositionOfLineAndCharacter(line: number, character: number): number { throw new Error("Method not implemented.") }
-    update(newText: string, textChangeRange: ts.TextChangeRange): ts.SourceFile { throw new Error("Method not implemented.") }
-    get endOfFileToken(): ts.Token<ts.SyntaxKind.EndOfFileToken> { return emptyImplementation() }
-    get fileName(): string { return emptyImplementation() }
-    get text() { return emptyImplementation() }
-    get amdDependencies(): readonly ts.AmdDependency[] { return emptyImplementation() }
-    get referencedFiles(): readonly ts.FileReference[] { return emptyImplementation() }
-    get typeReferenceDirectives(): readonly ts.FileReference[] { return emptyImplementation() }
-    get libReferenceDirectives(): readonly ts.FileReference[] { return emptyImplementation() }
-    get languageVariant(): ts.LanguageVariant { return emptyImplementation() }
-    get isDeclarationFile(): boolean { return emptyImplementation() }
-    get hasNoDefaultLib(): boolean { return emptyImplementation() }
-    get languageVersion(): ts.ScriptTarget { return emptyImplementation() }
+    getLineAndCharacterOfPosition(pos: number): ts.LineAndCharacter {
+        throw new Error('Method not implemented.');
+    }
+    getLineEndOfPosition(pos: number): number {
+        throw new Error('Method not implemented.');
+    }
+    getLineStarts(): readonly number[] {
+        throw new Error('Method not implemented.');
+    }
+    getPositionOfLineAndCharacter(line: number, character: number): number {
+        throw new Error('Method not implemented.');
+    }
+    update(newText: string, textChangeRange: ts.TextChangeRange): ts.SourceFile {
+        throw new Error('Method not implemented.');
+    }
+    get endOfFileToken(): ts.Token<ts.SyntaxKind.EndOfFileToken> {
+        return emptyImplementation();
+    }
+    get fileName(): string {
+        return emptyImplementation();
+    }
+    get text() {
+        return emptyImplementation();
+    }
+    get amdDependencies(): readonly ts.AmdDependency[] {
+        return emptyImplementation();
+    }
+    get referencedFiles(): readonly ts.FileReference[] {
+        return emptyImplementation();
+    }
+    get typeReferenceDirectives(): readonly ts.FileReference[] {
+        return emptyImplementation();
+    }
+    get libReferenceDirectives(): readonly ts.FileReference[] {
+        return emptyImplementation();
+    }
+    get languageVariant(): ts.LanguageVariant {
+        return emptyImplementation();
+    }
+    get isDeclarationFile(): boolean {
+        return emptyImplementation();
+    }
+    get hasNoDefaultLib(): boolean {
+        return emptyImplementation();
+    }
+    get languageVersion(): ts.ScriptTarget {
+        return emptyImplementation();
+    }
 
     // brands
-    _declarationBrand: any
+    _declarationBrand: any;
 }
 
-export abstract class LeftHandSideExpression extends Node<arkts.AstNode> implements ts.LeftHandSideExpression, Expression {
+export abstract class LeftHandSideExpression
+    extends Node<arkts.AstNode>
+    implements ts.LeftHandSideExpression, Expression
+{
     // brands
-    _leftHandSideExpressionBrand: any
-    _updateExpressionBrand: any
-    _unaryExpressionBrand: any
-    _expressionBrand: any
+    _leftHandSideExpressionBrand: any;
+    _updateExpressionBrand: any;
+    _unaryExpressionBrand: any;
+    _expressionBrand: any;
 }
 
 export class ExpressionStatement extends Node<arkts.ExpressionStatement> implements ts.ExpressionStatement, Statement {
     constructor(node: arkts.ExpressionStatement) {
-        super(node)
-        this.expression = unpackNode(this.node.expression)
+        super(node);
+        this.expression = unpackNode(this.node.expression);
     }
 
-    readonly expression: Expression
-    readonly kind: ts.SyntaxKind.ExpressionStatement = ts.SyntaxKind.ExpressionStatement
+    readonly expression: Expression;
+    readonly kind: ts.SyntaxKind.ExpressionStatement = ts.SyntaxKind.ExpressionStatement;
 
     // brands
-    _statementBrand: any
+    _statementBrand: any;
 }
 
 export class CallExpression extends Node<arkts.CallExpression> implements ts.CallExpression, LeftHandSideExpression {
     constructor(node: arkts.CallExpression) {
-        super(node)
-        this.expression = unpackNode(node.expression)
-        this.arguments = unpackNodeArray(node.arguments)
+        super(node);
+        this.expression = unpackNode(node.expression);
+        this.arguments = unpackNodeArray(node.arguments);
     }
 
-    readonly expression: LeftHandSideExpression
-    readonly arguments: NodeArray<Expression>
-    readonly kind: ts.SyntaxKind.CallExpression = ts.SyntaxKind.CallExpression
+    readonly expression: LeftHandSideExpression;
+    readonly arguments: NodeArray<Expression>;
+    readonly kind: ts.SyntaxKind.CallExpression = ts.SyntaxKind.CallExpression;
 
     // brands
-    _leftHandSideExpressionBrand: any
-    _updateExpressionBrand: any
-    _unaryExpressionBrand: any
-    _expressionBrand: any
-    _declarationBrand: any
+    _leftHandSideExpressionBrand: any;
+    _updateExpressionBrand: any;
+    _unaryExpressionBrand: any;
+    _expressionBrand: any;
+    _declarationBrand: any;
 }
 
-export class PropertyAccessExpression extends Node<arkts.MemberExpression> implements ts.PropertyAccessExpression, Expression {
+export class PropertyAccessExpression
+    extends Node<arkts.MemberExpression>
+    implements ts.PropertyAccessExpression, Expression
+{
     constructor(node: arkts.MemberExpression) {
-        super(node)
-        this.expression = unpackNode(node.object)
-        this.name = unpackNode(node.property)
+        super(node);
+        this.expression = unpackNode(node.object);
+        this.name = unpackNode(node.property);
     }
 
-    readonly expression: LeftHandSideExpression
-    readonly name: Identifier
-    readonly kind: ts.SyntaxKind.PropertyAccessExpression = ts.SyntaxKind.PropertyAccessExpression
+    readonly expression: LeftHandSideExpression;
+    readonly name: Identifier;
+    readonly kind: ts.SyntaxKind.PropertyAccessExpression = ts.SyntaxKind.PropertyAccessExpression;
 
     // brands
-    _memberExpressionBrand: any
-    _leftHandSideExpressionBrand: any
-    _updateExpressionBrand: any
-    _unaryExpressionBrand: any
-    _expressionBrand: any
-    _declarationBrand: any
+    _memberExpressionBrand: any;
+    _leftHandSideExpressionBrand: any;
+    _updateExpressionBrand: any;
+    _unaryExpressionBrand: any;
+    _expressionBrand: any;
+    _declarationBrand: any;
 }
 
 export class StringLiteral extends Node<arkts.StringLiteral> implements ts.StringLiteral {
     constructor(node: arkts.StringLiteral) {
-        super(node)
+        super(node);
 
-        this.text = node.str
+        this.text = node.str;
     }
 
-    readonly text: string
-    readonly kind: ts.SyntaxKind.StringLiteral = ts.SyntaxKind.StringLiteral
+    readonly text: string;
+    readonly kind: ts.SyntaxKind.StringLiteral = ts.SyntaxKind.StringLiteral;
 
     // brands
-    _literalExpressionBrand: any
-    _primaryExpressionBrand: any
-    _memberExpressionBrand: any
-    _leftHandSideExpressionBrand: any
-    _updateExpressionBrand: any
-    _unaryExpressionBrand: any
-    _expressionBrand: any
-    _declarationBrand: any
+    _literalExpressionBrand: any;
+    _primaryExpressionBrand: any;
+    _memberExpressionBrand: any;
+    _leftHandSideExpressionBrand: any;
+    _updateExpressionBrand: any;
+    _unaryExpressionBrand: any;
+    _expressionBrand: any;
+    _declarationBrand: any;
 }
 
 export class ClassDeclaration extends Node<arkts.ClassDeclaration> implements ts.ClassDeclaration {
     constructor(node: arkts.ClassDeclaration) {
-        super(node)
-        this.name = unpackNode(node.definition.name)
-        this.members = unpackNodeArray(node.definition.members)
-        this.typeParameters = unpackNodeArray(node.definition.typeParamsDecl?.parameters)
+        super(node);
+        this.name = unpackNode(node.definition.name);
+        this.members = unpackNodeArray(node.definition.members);
+        this.typeParameters = unpackNodeArray(node.definition.typeParamsDecl?.parameters);
     }
 
-    readonly name: Identifier
-    readonly members: NodeArray<ClassElement>
-    readonly typeParameters?: NodeArray<TypeParameterDeclaration>
-    readonly kind: ts.SyntaxKind.ClassDeclaration = ts.SyntaxKind.ClassDeclaration
+    readonly name: Identifier;
+    readonly members: NodeArray<ClassElement>;
+    readonly typeParameters?: NodeArray<TypeParameterDeclaration>;
+    readonly kind: ts.SyntaxKind.ClassDeclaration = ts.SyntaxKind.ClassDeclaration;
 
     // brands
-    _declarationBrand: any
-    _statementBrand: any
+    _declarationBrand: any;
+    _statementBrand: any;
 }
 
 export abstract class ClassElement extends Node<arkts.AstNode> implements ts.ClassElement {
     // brands
-    _declarationBrand: any
-    _classElementBrand: any
+    _declarationBrand: any;
+    _classElementBrand: any;
 }
 
 export type MemberName = Identifier | PrivateIdentifier;
@@ -412,13 +500,12 @@ export type MemberName = Identifier | PrivateIdentifier;
 export type PropertyName = Identifier | StringLiteral | NumericLiteral | PrivateIdentifier;
 
 // Improve: support
-export type DeclarationName =
-    | PropertyName
-    // | JsxAttributeName
-    // | StringLiteralLike
-    // | ElementAccessExpression
-    // | BindingPattern
-    // | EntityNameExpression;
+export type DeclarationName = PropertyName;
+// | JsxAttributeName
+// | StringLiteralLike
+// | ElementAccessExpression
+// | BindingPattern
+// | EntityNameExpression;
 
 export interface Declaration extends Node<arkts.AstNode> {}
 
@@ -426,14 +513,38 @@ export abstract class NamedDeclaration extends Node<arkts.AstNode> implements ts
     readonly name?: DeclarationName;
 
     // brands
-    _declarationBrand: any
+    _declarationBrand: any;
 }
 
-export type SignatureDeclaration = ts.CallSignatureDeclaration | ts.ConstructSignatureDeclaration | MethodSignature | ts.IndexSignatureDeclaration | FunctionTypeNode | ts.ConstructorTypeNode | ts.JSDocFunctionType | FunctionDeclaration | MethodDeclaration | ConstructorDeclaration | ts.AccessorDeclaration | FunctionExpression | ArrowFunction;
+export type SignatureDeclaration =
+    | ts.CallSignatureDeclaration
+    | ts.ConstructSignatureDeclaration
+    | MethodSignature
+    | ts.IndexSignatureDeclaration
+    | FunctionTypeNode
+    | ts.ConstructorTypeNode
+    | ts.JSDocFunctionType
+    | FunctionDeclaration
+    | MethodDeclaration
+    | ConstructorDeclaration
+    | ts.AccessorDeclaration
+    | FunctionExpression
+    | ArrowFunction;
 
 export interface SignatureDeclarationBase extends NamedDeclaration {}
 
-export type VariableLikeDeclaration = ts.VariableDeclaration | ParameterDeclaration | ts.BindingElement | PropertyDeclaration | ts.PropertyAssignment | PropertySignature | ts.JsxAttribute | ts.ShorthandPropertyAssignment | ts.EnumMember | ts.JSDocPropertyTag | ts.JSDocParameterTag;
+export type VariableLikeDeclaration =
+    | ts.VariableDeclaration
+    | ParameterDeclaration
+    | ts.BindingElement
+    | PropertyDeclaration
+    | ts.PropertyAssignment
+    | PropertySignature
+    | ts.JsxAttribute
+    | ts.ShorthandPropertyAssignment
+    | ts.EnumMember
+    | ts.JSDocPropertyTag
+    | ts.JSDocParameterTag;
 
 export interface FunctionLikeDeclarationBase extends SignatureDeclarationBase {
     // brands
@@ -442,414 +553,443 @@ export interface FunctionLikeDeclarationBase extends SignatureDeclarationBase {
 
 // Improve: support
 // export type FunctionLikeDeclaration = FunctionDeclaration | MethodDeclaration | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration | ConstructorDeclaration | FunctionExpression | ArrowFunction;
-export type FunctionLikeDeclaration = FunctionDeclaration | MethodDeclaration | ConstructorDeclaration | FunctionExpression | ArrowFunction;
+export type FunctionLikeDeclaration =
+    | FunctionDeclaration
+    | MethodDeclaration
+    | ConstructorDeclaration
+    | FunctionExpression
+    | ArrowFunction;
 
 export class MethodSignature extends Node<arkts.AstNode> implements ts.MethodSignature, SignatureDeclarationBase {
     constructor(node: arkts.AstNode) {
-        super(node)
+        super(node);
     }
 
     // readonly name: PropertyName
     // readonly parameters: NodeArray<ParameterDeclaration>
-    readonly kind: ts.SyntaxKind.MethodSignature = ts.SyntaxKind.MethodSignature
+    readonly kind: ts.SyntaxKind.MethodSignature = ts.SyntaxKind.MethodSignature;
 
     // Improve:
-    name: any
-    parameters: any
+    name: any;
+    parameters: any;
 
     // brands
-    _declarationBrand: any
-    _typeElementBrand: any
+    _declarationBrand: any;
+    _typeElementBrand: any;
 }
 
 // export class MethodDeclaration extends Node implements ts.MethodDeclaration, FunctionLikeDeclarationBase, ClassElement {
 export class MethodDeclaration extends Node<arkts.MethodDefinition> implements ts.MethodDeclaration, ClassElement {
     constructor(node: arkts.MethodDefinition) {
-        super(node)
-        this.name = unpackNode(node.name)
-        this.parameters = unpackNodeArray(node.scriptFunction.parameters)
-        this.body = unpackNode(node.scriptFunction.body)
+        super(node);
+        this.name = unpackNode(node.name);
+        this.parameters = unpackNodeArray(node.scriptFunction.parameters);
+        this.body = unpackNode(node.scriptFunction.body);
     }
 
     // tsc: readonly name?: PropertyName
-    readonly name: Identifier
-    readonly parameters: NodeArray<ParameterDeclaration>
+    readonly name: Identifier;
+    readonly parameters: NodeArray<ParameterDeclaration>;
     // tsc: readonly body?: FunctionBody | undefined
-    readonly body?: Block | undefined
-    readonly kind: ts.SyntaxKind.MethodDeclaration = ts.SyntaxKind.MethodDeclaration
+    readonly body?: Block | undefined;
+    readonly kind: ts.SyntaxKind.MethodDeclaration = ts.SyntaxKind.MethodDeclaration;
 
     // brands
-    _functionLikeDeclarationBrand: any
-    _classElementBrand: any
-    _objectLiteralBrand: any
-    _declarationBrand: any
+    _functionLikeDeclarationBrand: any;
+    _classElementBrand: any;
+    _objectLiteralBrand: any;
+    _declarationBrand: any;
 }
 
 // export class ConstructorDeclaration extends Node<arkts.MethodDefinition> implements ts.ConstructorDeclaration, FunctionLikeDeclarationBase, ClassElement {
-export class ConstructorDeclaration extends Node<arkts.MethodDefinition> implements ts.ConstructorDeclaration, ClassElement {
+export class ConstructorDeclaration
+    extends Node<arkts.MethodDefinition>
+    implements ts.ConstructorDeclaration, ClassElement
+{
     constructor(node: arkts.MethodDefinition) {
-        super(node)
-        this.name = unpackNode(node.name)
-        this.parameters = unpackNodeArray(node.scriptFunction.parameters)
-        this.body = unpackNode(node.scriptFunction.body)
+        super(node);
+        this.name = unpackNode(node.name);
+        this.parameters = unpackNodeArray(node.scriptFunction.parameters);
+        this.body = unpackNode(node.scriptFunction.body);
     }
 
     // ts: readonly name?: PropertyName
-    readonly name: Identifier
-    readonly parameters: NodeArray<ParameterDeclaration>
+    readonly name: Identifier;
+    readonly parameters: NodeArray<ParameterDeclaration>;
     // ts: readonly body?: FunctionBody | undefined
-    readonly body?: Block
-    readonly kind: ts.SyntaxKind.Constructor = ts.SyntaxKind.Constructor
+    readonly body?: Block;
+    readonly kind: ts.SyntaxKind.Constructor = ts.SyntaxKind.Constructor;
 
     // brands
-    _functionLikeDeclarationBrand: any
-    _classElementBrand: any
-    _objectLiteralBrand: any
-    _declarationBrand: any
+    _functionLikeDeclarationBrand: any;
+    _classElementBrand: any;
+    _objectLiteralBrand: any;
+    _declarationBrand: any;
 }
 
 // Improve: specify arkts.AstNode type
 export class PropertySignature extends Node<arkts.AstNode> implements ts.TypeElement {
     constructor(node: arkts.AstNode) {
-        super(node)
+        super(node);
     }
 
-    readonly name?: PropertyName
-    readonly kind: ts.SyntaxKind.PropertySignature = ts.SyntaxKind.PropertySignature
+    readonly name?: PropertyName;
+    readonly kind: ts.SyntaxKind.PropertySignature = ts.SyntaxKind.PropertySignature;
 
     // brands
-    _typeElementBrand: any
-    _declarationBrand: any
+    _typeElementBrand: any;
+    _declarationBrand: any;
 }
 
 // Improve: specify arkts.AstNode type
 export class PropertyDeclaration extends Node<arkts.AstNode> implements ts.PropertyDeclaration, ClassElement {
     constructor(node: arkts.AstNode) {
-        super(node)
+        super(node);
     }
 
-    readonly kind: ts.SyntaxKind.PropertyDeclaration = ts.SyntaxKind.PropertyDeclaration
+    readonly kind: ts.SyntaxKind.PropertyDeclaration = ts.SyntaxKind.PropertyDeclaration;
 
     // Improve:
-    name: any
+    name: any;
 
     // brands
-    _classElementBrand: any
-    _declarationBrand: any
+    _classElementBrand: any;
+    _declarationBrand: any;
 }
 
 // Improve: specify arkts.AstNode type
-export class GetAccessorDeclaration extends Node<arkts.AstNode> implements ts.GetAccessorDeclaration, FunctionLikeDeclarationBase, ClassElement {
+export class GetAccessorDeclaration
+    extends Node<arkts.AstNode>
+    implements ts.GetAccessorDeclaration, FunctionLikeDeclarationBase, ClassElement
+{
     constructor(node: arkts.AstNode) {
-        super(node)
+        super(node);
     }
 
     // readonly name: PropertyName
     // readonly parameters: NodeArray<ParameterDeclaration>
-    readonly kind: ts.SyntaxKind.GetAccessor = ts.SyntaxKind.GetAccessor
+    readonly kind: ts.SyntaxKind.GetAccessor = ts.SyntaxKind.GetAccessor;
 
     // Improve:
-    name: any
-    parameters: any
+    name: any;
+    parameters: any;
 
     // brands
-    _functionLikeDeclarationBrand: any
-    _declarationBrand: any
-    _classElementBrand: any
-    _typeElementBrand: any
-    _objectLiteralBrand: any
+    _functionLikeDeclarationBrand: any;
+    _declarationBrand: any;
+    _classElementBrand: any;
+    _typeElementBrand: any;
+    _objectLiteralBrand: any;
 }
 
 // Improve: specify arkts.AstNode type
-export class SetAccessorDeclaration extends Node<arkts.AstNode> implements ts.SetAccessorDeclaration, FunctionLikeDeclarationBase, ClassElement {
+export class SetAccessorDeclaration
+    extends Node<arkts.AstNode>
+    implements ts.SetAccessorDeclaration, FunctionLikeDeclarationBase, ClassElement
+{
     constructor(node: arkts.AstNode) {
-        super(node)
+        super(node);
     }
 
     // readonly name: PropertyName
     // readonly parameters: NodeArray<ParameterDeclaration>
-    readonly kind: ts.SyntaxKind.SetAccessor = ts.SyntaxKind.SetAccessor
+    readonly kind: ts.SyntaxKind.SetAccessor = ts.SyntaxKind.SetAccessor;
 
     // Improve:
-    name: any
-    parameters: any
+    name: any;
+    parameters: any;
 
     // brands
-    _functionLikeDeclarationBrand: any
-    _declarationBrand: any
-    _classElementBrand: any
-    _typeElementBrand: any
-    _objectLiteralBrand: any
+    _functionLikeDeclarationBrand: any;
+    _declarationBrand: any;
+    _classElementBrand: any;
+    _typeElementBrand: any;
+    _objectLiteralBrand: any;
 }
 
-export class ParameterDeclaration extends Node<arkts.ETSParameterExpression> implements ts.ParameterDeclaration, NamedDeclaration {
+export class ParameterDeclaration
+    extends Node<arkts.ETSParameterExpression>
+    implements ts.ParameterDeclaration, NamedDeclaration
+{
     constructor(node: arkts.ETSParameterExpression) {
-        super(node)
+        super(node);
     }
 
-    readonly kind: ts.SyntaxKind.Parameter = ts.SyntaxKind.Parameter
+    readonly kind: ts.SyntaxKind.Parameter = ts.SyntaxKind.Parameter;
 
     // Improve:
-    name: any
+    name: any;
 
     // brands
-    _declarationBrand: any
+    _declarationBrand: any;
 }
 
 export type BindingName = Identifier | ts.BindingPattern;
 
 export class VariableStatement extends Node<arkts.VariableDeclaration> implements ts.VariableStatement {
     constructor(node: arkts.VariableDeclaration) {
-        super(node)
-        this.declarationList = new VariableDeclarationList(node)
+        super(node);
+        this.declarationList = new VariableDeclarationList(node);
     }
 
-    readonly declarationList: VariableDeclarationList
-    readonly kind: ts.SyntaxKind.VariableStatement = ts.SyntaxKind.VariableStatement
+    readonly declarationList: VariableDeclarationList;
+    readonly kind: ts.SyntaxKind.VariableStatement = ts.SyntaxKind.VariableStatement;
 
     // brands
-    _statementBrand: any
+    _statementBrand: any;
 }
 
 export class VariableDeclarationList extends Node<arkts.VariableDeclaration> implements ts.VariableDeclarationList {
     constructor(node: arkts.VariableDeclaration) {
-        super(node)
-        this.declarations = unpackNodeArray(node.declarators)
+        super(node);
+        this.declarations = unpackNodeArray(node.declarators);
     }
 
-    readonly declarations: NodeArray<VariableDeclaration>
-    get flags(): ts.NodeFlags { return unpackVariableDeclarationKind(this.node.declarationKind) }
-    readonly kind: ts.SyntaxKind.VariableDeclarationList = ts.SyntaxKind.VariableDeclarationList
+    readonly declarations: NodeArray<VariableDeclaration>;
+    get flags(): ts.NodeFlags {
+        return unpackVariableDeclarationKind(this.node.declarationKind);
+    }
+    readonly kind: ts.SyntaxKind.VariableDeclarationList = ts.SyntaxKind.VariableDeclarationList;
 }
 
-export class VariableDeclaration extends Node<arkts.VariableDeclarator> implements ts.VariableDeclaration, NamedDeclaration {
+export class VariableDeclaration
+    extends Node<arkts.VariableDeclarator>
+    implements ts.VariableDeclaration, NamedDeclaration
+{
     constructor(node: arkts.VariableDeclarator) {
-        super(node)
-        this.name = unpackNode(node.name)
+        super(node);
+        this.name = unpackNode(node.name);
     }
 
-    readonly name: Identifier
-    readonly kind: ts.SyntaxKind.VariableDeclaration = ts.SyntaxKind.VariableDeclaration
+    readonly name: Identifier;
+    readonly kind: ts.SyntaxKind.VariableDeclaration = ts.SyntaxKind.VariableDeclaration;
 
     // brands
-    _declarationBrand: any
+    _declarationBrand: any;
 }
 
 export class TypeParameterDeclaration extends Node<arkts.TSTypeParameter> implements ts.TypeParameterDeclaration {
     constructor(node: arkts.TSTypeParameter) {
-        super(node)
-        this.name = unpackNode(node.name)
+        super(node);
+        this.name = unpackNode(node.name);
     }
 
-    readonly name: Identifier
-    readonly kind: ts.SyntaxKind.TypeParameter = ts.SyntaxKind.TypeParameter
+    readonly name: Identifier;
+    readonly kind: ts.SyntaxKind.TypeParameter = ts.SyntaxKind.TypeParameter;
 
     // brands
-    _declarationBrand: any
+    _declarationBrand: any;
 }
 
 export abstract class TypeNode extends Node<arkts.AstNode> implements ts.TypeNode {
     // brands
-    _typeNodeBrand: any
+    _typeNodeBrand: any;
 }
 
-export class KeywordTypeNode extends Node<arkts.ETSPrimitiveType | arkts.ETSTypeReference> implements ts.KeywordTypeNode, TypeNode {
+export class KeywordTypeNode
+    extends Node<arkts.ETSPrimitiveType | arkts.ETSTypeReference>
+    implements ts.KeywordTypeNode, TypeNode
+{
     constructor(node: arkts.ETSPrimitiveType | arkts.ETSTypeReference) {
-        super(node)
+        super(node);
     }
 
-    readonly kind: ts.KeywordTypeSyntaxKind = ts.SyntaxKind.UnknownKeyword
+    readonly kind: ts.KeywordTypeSyntaxKind = ts.SyntaxKind.UnknownKeyword;
 
     // brands
-    _typeNodeBrand: any
+    _typeNodeBrand: any;
 }
 
 export class TypeReferenceNode extends Node<arkts.AstNode> implements ts.TypeReferenceNode, TypeNode {
     constructor(node: arkts.AstNode) {
-        super(node)
+        super(node);
     }
 
-    readonly kind: ts.SyntaxKind.TypeReference = ts.SyntaxKind.TypeReference
+    readonly kind: ts.SyntaxKind.TypeReference = ts.SyntaxKind.TypeReference;
 
     // Improve:
-    typeName: any
+    typeName: any;
 
     // brands
-    _typeNodeBrand: any
+    _typeNodeBrand: any;
 }
 
-export class FunctionTypeNode extends Node<arkts.AstNode> implements ts.FunctionTypeNode, TypeNode, SignatureDeclarationBase {
+export class FunctionTypeNode
+    extends Node<arkts.AstNode>
+    implements ts.FunctionTypeNode, TypeNode, SignatureDeclarationBase
+{
     constructor(node: arkts.AstNode) {
-        super(node)
+        super(node);
     }
 
-    readonly name?: DeclarationName
-    readonly kind: ts.SyntaxKind.FunctionType = ts.SyntaxKind.FunctionType
+    readonly name?: DeclarationName;
+    readonly kind: ts.SyntaxKind.FunctionType = ts.SyntaxKind.FunctionType;
 
     // Improve: support minimal interface
-    parameters: any
-    type: any
+    parameters: any;
+    type: any;
 
     // brands
-    _typeNodeBrand: any
-    _declarationBrand: any
+    _typeNodeBrand: any;
+    _declarationBrand: any;
 }
 
 export class UnionTypeNode extends Node<arkts.ETSUnionType> implements ts.UnionTypeNode, TypeNode {
     constructor(node: arkts.ETSUnionType) {
-        super(node)
-        this.types = unpackNodeArray(node.types)
+        super(node);
+        this.types = unpackNodeArray(node.types);
     }
 
-    readonly types: NodeArray<TypeNode>
-    readonly kind: ts.SyntaxKind.UnionType = ts.SyntaxKind.UnionType
+    readonly types: NodeArray<TypeNode>;
+    readonly kind: ts.SyntaxKind.UnionType = ts.SyntaxKind.UnionType;
 
     // brands
-    _typeNodeBrand: any
+    _typeNodeBrand: any;
 }
 
 export class ReturnStatement extends Node<arkts.ReturnStatement> implements ts.ReturnStatement, Statement {
     constructor(node: arkts.ReturnStatement) {
-        super(node)
-        this.expression = unpackNode(node.argument)
+        super(node);
+        this.expression = unpackNode(node.argument);
     }
 
-    readonly expression: Expression | undefined
-    readonly kind: ts.SyntaxKind.ReturnStatement = ts.SyntaxKind.ReturnStatement
+    readonly expression: Expression | undefined;
+    readonly kind: ts.SyntaxKind.ReturnStatement = ts.SyntaxKind.ReturnStatement;
 
     // brands
-    _statementBrand: any
+    _statementBrand: any;
 }
 
 export class IfStatement extends Node<arkts.IfStatement> implements ts.IfStatement {
     constructor(node: arkts.IfStatement) {
-        super(node)
+        super(node);
     }
 
-    readonly kind: ts.SyntaxKind.IfStatement = ts.SyntaxKind.IfStatement
+    readonly kind: ts.SyntaxKind.IfStatement = ts.SyntaxKind.IfStatement;
 
     // Improve:
-    thenStatement: any
-    expression: any
+    thenStatement: any;
+    expression: any;
 
     // brands
-    _statementBrand: any
+    _statementBrand: any;
 }
 
 export class BinaryExpression extends Node<arkts.BinaryExpression> implements ts.BinaryExpression {
     constructor(node: arkts.BinaryExpression) {
-        super(node)
+        super(node);
     }
 
-    readonly kind: ts.SyntaxKind.BinaryExpression = ts.SyntaxKind.BinaryExpression
+    readonly kind: ts.SyntaxKind.BinaryExpression = ts.SyntaxKind.BinaryExpression;
 
     // Improve:
-    left: any
-    right: any
-    operatorToken: any
+    left: any;
+    right: any;
+    operatorToken: any;
 
     // brands
-    _expressionBrand: any
-    _declarationBrand: any
+    _expressionBrand: any;
+    _declarationBrand: any;
 }
 
 export class AssignmentExpression extends Node<arkts.AssignmentExpression> implements ts.AssignmentExpression<any> {
     constructor(node: arkts.AssignmentExpression) {
-        super(node)
+        super(node);
     }
 
-    readonly kind: ts.SyntaxKind.BinaryExpression = ts.SyntaxKind.BinaryExpression
+    readonly kind: ts.SyntaxKind.BinaryExpression = ts.SyntaxKind.BinaryExpression;
 
     // Improve:
-    right: any
-    left: any
-    operatorToken: any
+    right: any;
+    left: any;
+    operatorToken: any;
 
     // brands
-    _expressionBrand: any
-    _declarationBrand: any
+    _expressionBrand: any;
+    _declarationBrand: any;
 }
 
 export class ArrowFunction extends Node<arkts.ArrowFunctionExpression> implements ts.ArrowFunction {
     constructor(node: arkts.ArrowFunctionExpression) {
-        super(node)
+        super(node);
         if (node.scriptFunction.body === undefined) {
-            throwError('node.scriptFunction.body not expected to be undefined')
+            throwError('node.scriptFunction.body not expected to be undefined');
         }
-        this.body = unpackNode(node.scriptFunction.body)
-        this.parameters = unpackNodeArray(node.scriptFunction.parameters)
+        this.body = unpackNode(node.scriptFunction.body);
+        this.parameters = unpackNodeArray(node.scriptFunction.parameters);
     }
 
-    get name(): never { return throwError(`name doesn't exist for ArrowFunction`) }
-    readonly body: Block
-    readonly parameters: NodeArray<ParameterDeclaration>
-    readonly kind: ts.SyntaxKind.ArrowFunction = ts.SyntaxKind.ArrowFunction
+    get name(): never {
+        return throwError(`name doesn't exist for ArrowFunction`);
+    }
+    readonly body: Block;
+    readonly parameters: NodeArray<ParameterDeclaration>;
+    readonly kind: ts.SyntaxKind.ArrowFunction = ts.SyntaxKind.ArrowFunction;
 
     // Improve:
-    equalsGreaterThanToken: any
+    equalsGreaterThanToken: any;
 
     // brands
-    _expressionBrand: any
-    _functionLikeDeclarationBrand: any
-    _declarationBrand: any
+    _expressionBrand: any;
+    _functionLikeDeclarationBrand: any;
+    _declarationBrand: any;
 }
 
 export class NumericLiteral extends Node<arkts.NumberLiteral> implements ts.NumericLiteral, Declaration {
     constructor(node: arkts.NumberLiteral) {
-        super(node)
+        super(node);
 
-        this.text = `${node.value}`
+        this.text = `${node.value}`;
     }
 
-    readonly text: string
-    readonly kind: ts.SyntaxKind.NumericLiteral = ts.SyntaxKind.NumericLiteral
+    readonly text: string;
+    readonly kind: ts.SyntaxKind.NumericLiteral = ts.SyntaxKind.NumericLiteral;
 
     // brands
-    _literalExpressionBrand: any
-    _declarationBrand: any
-    _primaryExpressionBrand: any
-    _memberExpressionBrand: any
-    _leftHandSideExpressionBrand: any
-    _updateExpressionBrand: any
-    _unaryExpressionBrand: any
-    _expressionBrand: any
+    _literalExpressionBrand: any;
+    _declarationBrand: any;
+    _primaryExpressionBrand: any;
+    _memberExpressionBrand: any;
+    _leftHandSideExpressionBrand: any;
+    _updateExpressionBrand: any;
+    _unaryExpressionBrand: any;
+    _expressionBrand: any;
 }
 
 export class SuperExpression extends Node<arkts.SuperExpression> implements ts.SuperExpression {
     constructor(node: arkts.SuperExpression) {
-        super(node)
+        super(node);
     }
 
-    readonly kind: ts.SyntaxKind.SuperKeyword = ts.SyntaxKind.SuperKeyword
+    readonly kind: ts.SyntaxKind.SuperKeyword = ts.SyntaxKind.SuperKeyword;
 
     // brands
-    _primaryExpressionBrand: any
-    _memberExpressionBrand: any
-    _leftHandSideExpressionBrand: any
-    _updateExpressionBrand: any
-    _unaryExpressionBrand: any
-    _expressionBrand: any
+    _primaryExpressionBrand: any;
+    _memberExpressionBrand: any;
+    _leftHandSideExpressionBrand: any;
+    _updateExpressionBrand: any;
+    _unaryExpressionBrand: any;
+    _expressionBrand: any;
 }
 
 export class HeritageClause extends Node<arkts.SuperExpression> implements ts.HeritageClause {
     constructor(node: arkts.SuperExpression) {
-        super(node)
+        super(node);
     }
 
-    readonly kind: ts.SyntaxKind.HeritageClause = ts.SyntaxKind.HeritageClause
+    readonly kind: ts.SyntaxKind.HeritageClause = ts.SyntaxKind.HeritageClause;
     // token: ts.SyntaxKind.ExtendsKeyword | ts.SyntaxKind.ImplementsKeyword
     // types: ts.NodeArray<ts.ExpressionWithTypeArguments>
 
     // Improve:
-    token: any
-    types: any
+    token: any;
+    types: any;
 }
 
-
 // Improve: there is no ParenthesizedExpression in ArkTS,
 // so for temporary solution we're just gonna ignore this type of nodes
 // and replace it with Expression underneath
-export type ParenthesizedExpression = Expression
+export type ParenthesizedExpression = Expression;
 // export class ParenthesizedExpression extends Node<undefined> implements ts.ParenthesizedExpression {
 //     constructor(expression: Expression) {
 //         super(undefined)
@@ -871,65 +1011,65 @@ export type ParenthesizedExpression = Expression
 // Improve:
 export class ImportDeclaration extends Node<arkts.UnsupportedNode> implements ts.ImportDeclaration {
     constructor(node: arkts.UnsupportedNode) {
-        super(node)
+        super(node);
     }
 
-    readonly kind: ts.SyntaxKind.ImportDeclaration = ts.SyntaxKind.ImportDeclaration
+    readonly kind: ts.SyntaxKind.ImportDeclaration = ts.SyntaxKind.ImportDeclaration;
 
     // Improve:
-    moduleSpecifier: any
+    moduleSpecifier: any;
 
     // brands
-    _statementBrand: any
+    _statementBrand: any;
 }
 
 // Improve:
 export class ImportClause extends Node<arkts.UnsupportedNode> implements ts.ImportClause {
     constructor(node: arkts.UnsupportedNode) {
-        super(node)
+        super(node);
     }
 
-    readonly kind: ts.SyntaxKind.ImportClause = ts.SyntaxKind.ImportClause
+    readonly kind: ts.SyntaxKind.ImportClause = ts.SyntaxKind.ImportClause;
 
     // Improve:
-    isTypeOnly: any
+    isTypeOnly: any;
 
     // brands
-    _declarationBrand: any
+    _declarationBrand: any;
 }
 
 // Improve:
 export class NamedImports extends Node<arkts.UnsupportedNode> implements ts.NamedImports {
     constructor(node: arkts.UnsupportedNode) {
-        super(node)
+        super(node);
     }
 
-    readonly kind: ts.SyntaxKind.NamedImports = ts.SyntaxKind.NamedImports
+    readonly kind: ts.SyntaxKind.NamedImports = ts.SyntaxKind.NamedImports;
 
     // Improve:
-    elements: any
+    elements: any;
 }
 
 export class ImportSpecifier extends Node<arkts.Identifier> implements ts.ImportSpecifier {
     constructor(node: arkts.Identifier) {
-        super(node)
-        this.name = unpackNode(this.node)
+        super(node);
+        this.name = unpackNode(this.node);
     }
 
-    readonly name: Identifier
-    readonly kind: ts.SyntaxKind.ImportSpecifier = ts.SyntaxKind.ImportSpecifier
+    readonly name: Identifier;
+    readonly kind: ts.SyntaxKind.ImportSpecifier = ts.SyntaxKind.ImportSpecifier;
 
     // Improve:
-    isTypeOnly: any
+    isTypeOnly: any;
 
     // brands
-    _declarationBrand: any
+    _declarationBrand: any;
 }
 
 export class UnsupportedNode extends Node<arkts.AstNode> implements ts.Node {
     constructor(node: arkts.AstNode) {
-        super(node)
+        super(node);
     }
 
-    readonly kind: ts.SyntaxKind = SyntaxKind.Unknown
+    readonly kind: ts.SyntaxKind = SyntaxKind.Unknown;
 }