@idlizer/arktscgen 2.1.9-arktscgen-9 → 2.1.10-arktscgen-3

package/build/libarkts-copy/src/generated/peers/ETSParameterExpression.ts

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -38,15 +37,15 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { Identifier } from "./Identifier"
 import { SpreadElement } from "./SpreadElement"
+import { SrcDumper } from "./SrcDumper"
 import { TypeNode } from "./TypeNode"
 
 export class ETSParameterExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 82)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createETSParameterExpression(identOrSpread: AnnotatedExpression | undefined, isOptional: boolean, annotations?: readonly AnnotationUsage[]): ETSParameterExpression {
-        const result: ETSParameterExpression = new ETSParameterExpression(global.generatedEs2panda._CreateETSParameterExpression(global.context, passNode(identOrSpread), isOptional))
+        const result: ETSParameterExpression = new ETSParameterExpression(global.generatedEs2panda._CreateETSParameterExpression(global.context, passNode(identOrSpread), isOptional), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -55,7 +54,7 @@ export class ETSParameterExpression extends Expression {
         return result
     }
     static updateETSParameterExpression(original: ETSParameterExpression | undefined, identOrSpread: AnnotatedExpression | undefined, isOptional: boolean, annotations?: readonly AnnotationUsage[]): ETSParameterExpression {
-        const result: ETSParameterExpression = new ETSParameterExpression(global.generatedEs2panda._UpdateETSParameterExpression(global.context, passNode(original), passNode(identOrSpread), isOptional))
+        const result: ETSParameterExpression = new ETSParameterExpression(global.generatedEs2panda._UpdateETSParameterExpression(global.context, passNode(original), passNode(identOrSpread), isOptional), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -64,7 +63,7 @@ export class ETSParameterExpression extends Expression {
         return result
     }
     static create1ETSParameterExpression(identOrSpread?: AnnotatedExpression, initializer?: Expression, annotations?: readonly AnnotationUsage[]): ETSParameterExpression {
-        const result: ETSParameterExpression = new ETSParameterExpression(global.generatedEs2panda._CreateETSParameterExpression1(global.context, passNode(identOrSpread), passNode(initializer)))
+        const result: ETSParameterExpression = new ETSParameterExpression(global.generatedEs2panda._CreateETSParameterExpression1(global.context, passNode(identOrSpread), passNode(initializer)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -73,7 +72,7 @@ export class ETSParameterExpression extends Expression {
         return result
     }
     static update1ETSParameterExpression(original?: ETSParameterExpression, identOrSpread?: AnnotatedExpression, initializer?: Expression, annotations?: readonly AnnotationUsage[]): ETSParameterExpression {
-        const result: ETSParameterExpression = new ETSParameterExpression(global.generatedEs2panda._UpdateETSParameterExpression1(global.context, passNode(original), passNode(identOrSpread), passNode(initializer)))
+        const result: ETSParameterExpression = new ETSParameterExpression(global.generatedEs2panda._UpdateETSParameterExpression1(global.context, passNode(original), passNode(identOrSpread), passNode(initializer)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -85,7 +84,7 @@ export class ETSParameterExpression extends Expression {
         return unpackString(global.generatedEs2panda._ETSParameterExpressionNameConst(global.context, this.peer))
     }
     get ident(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._ETSParameterExpressionIdent(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ETSParameterExpressionIdent(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)
     }
     /** @deprecated */
     setIdent(ident?: Identifier): this {
@@ -93,7 +92,7 @@ export class ETSParameterExpression extends Expression {
         return this
     }
     get spread(): SpreadElement | undefined {
-        return unpackNode(global.generatedEs2panda._ETSParameterExpressionSpread(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ETSParameterExpressionSpread(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_SPREAD_ELEMENT)
     }
     /** @deprecated */
     setSpread(spread?: SpreadElement): this {
@@ -101,7 +100,7 @@ export class ETSParameterExpression extends Expression {
         return this
     }
     get restParameter(): SpreadElement | undefined {
-        return unpackNode(global.generatedEs2panda._ETSParameterExpressionRestParameter(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ETSParameterExpressionRestParameter(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_SPREAD_ELEMENT)
     }
     get initializer(): Expression | undefined {
         return unpackNode(global.generatedEs2panda._ETSParameterExpressionInitializer(global.context, this.peer))
@@ -146,9 +145,12 @@ export class ETSParameterExpression extends Expression {
         global.generatedEs2panda._ETSParameterExpressionSetRequiredParams(global.context, this.peer, extraValue)
         return this
     }
+    get hasAnnotations(): boolean {
+        return global.generatedEs2panda._ETSParameterExpressionHasAnnotationsConst(global.context, this.peer)
+    }
     /** @deprecated */
-    emplaceAnnotations(source?: AnnotationUsage): this {
-        global.generatedEs2panda._ETSParameterExpressionEmplaceAnnotations(global.context, this.peer, passNode(source))
+    emplaceAnnotation(source?: AnnotationUsage): this {
+        global.generatedEs2panda._ETSParameterExpressionEmplaceAnnotation(global.context, this.peer, passNode(source))
         return this
     }
     /** @deprecated */
@@ -157,15 +159,15 @@ export class ETSParameterExpression extends Expression {
         return this
     }
     /** @deprecated */
-    setValueAnnotations(source: AnnotationUsage | undefined, index: number): this {
-        global.generatedEs2panda._ETSParameterExpressionSetValueAnnotations(global.context, this.peer, passNode(source), index)
+    dumpAnnotations(dumper?: SrcDumper): this {
+        global.generatedEs2panda._ETSParameterExpressionDumpAnnotationsConst(global.context, this.peer, passNode(dumper))
         return this
     }
     get annotationsForUpdate(): readonly AnnotationUsage[] {
-        return unpackNodeArray(global.generatedEs2panda._ETSParameterExpressionAnnotationsForUpdate(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._ETSParameterExpressionAnnotationsForUpdate(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE)
     }
     get annotations(): readonly AnnotationUsage[] {
-        return unpackNodeArray(global.generatedEs2panda._ETSParameterExpressionAnnotations(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._ETSParameterExpressionAnnotations(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE)
     }
     /** @deprecated */
     setAnnotations(annotationList: readonly AnnotationUsage[]): this {
@@ -177,16 +179,11 @@ export class ETSParameterExpression extends Expression {
         global.generatedEs2panda._ETSParameterExpressionSetAnnotations1(global.context, this.peer, passNodeArray(annotationList), annotationList.length)
         return this
     }
-    /** @deprecated */
-    addAnnotations(annotations?: AnnotationUsage): this {
-        global.generatedEs2panda._ETSParameterExpressionAddAnnotations(global.context, this.peer, passNode(annotations))
-        return this
-    }
     protected readonly brandETSParameterExpression: undefined
 }
 export function isETSParameterExpression(node: object | undefined): node is ETSParameterExpression {
     return node instanceof ETSParameterExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION, (peer: KNativePointer) => new ETSParameterExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION, (peer: KNativePointer) => new ETSParameterExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION))
 }

package/build/libarkts-copy/src/generated/peers/ETSPrimitiveType.ts

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,17 +36,16 @@ import { Es2pandaPrimitiveType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 
 export class ETSPrimitiveType extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 71)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createETSPrimitiveType(type: Es2pandaPrimitiveType): ETSPrimitiveType {
-        const result: ETSPrimitiveType = new ETSPrimitiveType(global.generatedEs2panda._CreateETSPrimitiveType(global.context, type))
+        const result: ETSPrimitiveType = new ETSPrimitiveType(global.generatedEs2panda._CreateETSPrimitiveType(global.context, type), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PRIMITIVE_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static updateETSPrimitiveType(original: ETSPrimitiveType | undefined, type: Es2pandaPrimitiveType): ETSPrimitiveType {
-        const result: ETSPrimitiveType = new ETSPrimitiveType(global.generatedEs2panda._UpdateETSPrimitiveType(global.context, passNode(original), type))
+        const result: ETSPrimitiveType = new ETSPrimitiveType(global.generatedEs2panda._UpdateETSPrimitiveType(global.context, passNode(original), type), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PRIMITIVE_TYPE)
         result.setChildrenParentPtr()
         return result
     }
@@ -60,5 +58,5 @@ export function isETSPrimitiveType(node: object | undefined): node is ETSPrimiti
     return node instanceof ETSPrimitiveType
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PRIMITIVE_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PRIMITIVE_TYPE, (peer: KNativePointer) => new ETSPrimitiveType(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PRIMITIVE_TYPE, (peer: KNativePointer) => new ETSPrimitiveType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PRIMITIVE_TYPE))
 }

package/build/libarkts-copy/src/generated/peers/ETSReExportDeclaration.ts

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,12 +36,11 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Statement } from "./Statement"
 
 export class ETSReExportDeclaration extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 58)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     get eTSImportDeclarations(): ETSImportDeclaration | undefined {
-        return unpackNode(global.generatedEs2panda._ETSReExportDeclarationGetETSImportDeclarations(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ETSReExportDeclarationGetETSImportDeclarations(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION)
     }
     get programPath(): string {
         return unpackString(global.generatedEs2panda._ETSReExportDeclarationGetProgramPathConst(global.context, this.peer))
@@ -53,5 +51,5 @@ export function isETSReExportDeclaration(node: object | undefined): node is ETSR
     return node instanceof ETSReExportDeclaration
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_REEXPORT_STATEMENT)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_REEXPORT_STATEMENT, (peer: KNativePointer) => new ETSReExportDeclaration(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_REEXPORT_STATEMENT, (peer: KNativePointer) => new ETSReExportDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_REEXPORT_STATEMENT))
 }

package/build/libarkts-copy/src/generated/peers/ETSStringLiteralType.ts

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -36,17 +35,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 
 export class ETSStringLiteralType extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 67)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createETSStringLiteralType(value: string): ETSStringLiteralType {
-        const result: ETSStringLiteralType = new ETSStringLiteralType(global.generatedEs2panda._CreateETSStringLiteralType(global.context, value))
+        const result: ETSStringLiteralType = new ETSStringLiteralType(global.generatedEs2panda._CreateETSStringLiteralType(global.context, value), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_STRING_LITERAL_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static updateETSStringLiteralType(original: ETSStringLiteralType | undefined, value: string): ETSStringLiteralType {
-        const result: ETSStringLiteralType = new ETSStringLiteralType(global.generatedEs2panda._UpdateETSStringLiteralType(global.context, passNode(original), value))
+        const result: ETSStringLiteralType = new ETSStringLiteralType(global.generatedEs2panda._UpdateETSStringLiteralType(global.context, passNode(original), value), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_STRING_LITERAL_TYPE)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +54,5 @@ export function isETSStringLiteralType(node: object | undefined): node is ETSStr
     return node instanceof ETSStringLiteralType
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_STRING_LITERAL_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_STRING_LITERAL_TYPE, (peer: KNativePointer) => new ETSStringLiteralType(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_STRING_LITERAL_TYPE, (peer: KNativePointer) => new ETSStringLiteralType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_STRING_LITERAL_TYPE))
 }

package/build/libarkts-copy/src/generated/peers/ETSStructDeclaration.ts

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,17 +36,16 @@ import { ClassDefinition } from "./ClassDefinition"
 import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 
 export class ETSStructDeclaration extends ClassDeclaration {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 86)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createETSStructDeclaration(def?: ClassDefinition): ETSStructDeclaration {
-        const result: ETSStructDeclaration = new ETSStructDeclaration(global.generatedEs2panda._CreateETSStructDeclaration(global.context, passNode(def)))
+        const result: ETSStructDeclaration = new ETSStructDeclaration(global.generatedEs2panda._CreateETSStructDeclaration(global.context, passNode(def)), Es2pandaAstNodeType.AST_NODE_TYPE_STRUCT_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     static updateETSStructDeclaration(original?: ETSStructDeclaration, def?: ClassDefinition): ETSStructDeclaration {
-        const result: ETSStructDeclaration = new ETSStructDeclaration(global.generatedEs2panda._UpdateETSStructDeclaration(global.context, passNode(original), passNode(def)))
+        const result: ETSStructDeclaration = new ETSStructDeclaration(global.generatedEs2panda._UpdateETSStructDeclaration(global.context, passNode(original), passNode(def)), Es2pandaAstNodeType.AST_NODE_TYPE_STRUCT_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
@@ -57,5 +55,5 @@ export function isETSStructDeclaration(node: object | undefined): node is ETSStr
     return node instanceof ETSStructDeclaration
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_STRUCT_DECLARATION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_STRUCT_DECLARATION, (peer: KNativePointer) => new ETSStructDeclaration(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_STRUCT_DECLARATION, (peer: KNativePointer) => new ETSStructDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_STRUCT_DECLARATION))
 }

package/build/libarkts-copy/src/generated/peers/ETSTuple.ts

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -36,37 +35,36 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 
 export class ETSTuple extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 83)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createETSTuple(): ETSTuple {
-        const result: ETSTuple = new ETSTuple(global.generatedEs2panda._CreateETSTuple(global.context))
+        const result: ETSTuple = new ETSTuple(global.generatedEs2panda._CreateETSTuple(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TUPLE)
         result.setChildrenParentPtr()
         return result
     }
     static updateETSTuple(original?: ETSTuple): ETSTuple {
-        const result: ETSTuple = new ETSTuple(global.generatedEs2panda._UpdateETSTuple(global.context, passNode(original)))
+        const result: ETSTuple = new ETSTuple(global.generatedEs2panda._UpdateETSTuple(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TUPLE)
         result.setChildrenParentPtr()
         return result
     }
     static create1ETSTuple(size: number): ETSTuple {
-        const result: ETSTuple = new ETSTuple(global.generatedEs2panda._CreateETSTuple1(global.context, size))
+        const result: ETSTuple = new ETSTuple(global.generatedEs2panda._CreateETSTuple1(global.context, size), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TUPLE)
         result.setChildrenParentPtr()
         return result
     }
     static update1ETSTuple(original: ETSTuple | undefined, size: number): ETSTuple {
-        const result: ETSTuple = new ETSTuple(global.generatedEs2panda._UpdateETSTuple1(global.context, passNode(original), size))
+        const result: ETSTuple = new ETSTuple(global.generatedEs2panda._UpdateETSTuple1(global.context, passNode(original), size), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TUPLE)
         result.setChildrenParentPtr()
         return result
     }
     static create2ETSTuple(typeList: readonly TypeNode[]): ETSTuple {
-        const result: ETSTuple = new ETSTuple(global.generatedEs2panda._CreateETSTuple2(global.context, passNodeArray(typeList), typeList.length))
+        const result: ETSTuple = new ETSTuple(global.generatedEs2panda._CreateETSTuple2(global.context, passNodeArray(typeList), typeList.length), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TUPLE)
         result.setChildrenParentPtr()
         return result
     }
     static update2ETSTuple(original: ETSTuple | undefined, typeList: readonly TypeNode[]): ETSTuple {
-        const result: ETSTuple = new ETSTuple(global.generatedEs2panda._UpdateETSTuple2(global.context, passNode(original), passNodeArray(typeList), typeList.length))
+        const result: ETSTuple = new ETSTuple(global.generatedEs2panda._UpdateETSTuple2(global.context, passNode(original), passNodeArray(typeList), typeList.length), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TUPLE)
         result.setChildrenParentPtr()
         return result
     }
@@ -87,5 +85,5 @@ export function isETSTuple(node: object | undefined): node is ETSTuple {
     return node instanceof ETSTuple
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TUPLE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TUPLE, (peer: KNativePointer) => new ETSTuple(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TUPLE, (peer: KNativePointer) => new ETSTuple(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TUPLE))
 }

package/build/libarkts-copy/src/generated/peers/ETSTypeReference.ts

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -38,25 +37,24 @@ import { Identifier } from "./Identifier"
 import { TypeNode } from "./TypeNode"
 
 export class ETSTypeReference extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 74)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createETSTypeReference(part?: ETSTypeReferencePart): ETSTypeReference {
-        const result: ETSTypeReference = new ETSTypeReference(global.generatedEs2panda._CreateETSTypeReference(global.context, passNode(part)))
+        const result: ETSTypeReference = new ETSTypeReference(global.generatedEs2panda._CreateETSTypeReference(global.context, passNode(part)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE)
         result.setChildrenParentPtr()
         return result
     }
     static updateETSTypeReference(original?: ETSTypeReference, part?: ETSTypeReferencePart): ETSTypeReference {
-        const result: ETSTypeReference = new ETSTypeReference(global.generatedEs2panda._UpdateETSTypeReference(global.context, passNode(original), passNode(part)))
+        const result: ETSTypeReference = new ETSTypeReference(global.generatedEs2panda._UpdateETSTypeReference(global.context, passNode(original), passNode(part)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE)
         result.setChildrenParentPtr()
         return result
     }
     get part(): ETSTypeReferencePart | undefined {
-        return unpackNode(global.generatedEs2panda._ETSTypeReferencePart(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ETSTypeReferencePart(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE_PART)
     }
     get baseName(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._ETSTypeReferenceBaseNameConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ETSTypeReferenceBaseNameConst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)
     }
     protected readonly brandETSTypeReference: undefined
 }
@@ -64,5 +62,5 @@ export function isETSTypeReference(node: object | undefined): node is ETSTypeRef
     return node instanceof ETSTypeReference
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE, (peer: KNativePointer) => new ETSTypeReference(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE, (peer: KNativePointer) => new ETSTypeReference(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE))
 }

package/build/libarkts-copy/src/generated/peers/ETSTypeReferencePart.ts

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -39,36 +38,35 @@ import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation"
 import { TypeNode } from "./TypeNode"
 
 export class ETSTypeReferencePart extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 75)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createETSTypeReferencePart(name?: Expression, typeParams?: TSTypeParameterInstantiation, prev?: ETSTypeReferencePart): ETSTypeReferencePart {
-        const result: ETSTypeReferencePart = new ETSTypeReferencePart(global.generatedEs2panda._CreateETSTypeReferencePart(global.context, passNode(name), passNode(typeParams), passNode(prev)))
+        const result: ETSTypeReferencePart = new ETSTypeReferencePart(global.generatedEs2panda._CreateETSTypeReferencePart(global.context, passNode(name), passNode(typeParams), passNode(prev)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE_PART)
         result.setChildrenParentPtr()
         return result
     }
     static updateETSTypeReferencePart(original?: ETSTypeReferencePart, name?: Expression, typeParams?: TSTypeParameterInstantiation, prev?: ETSTypeReferencePart): ETSTypeReferencePart {
-        const result: ETSTypeReferencePart = new ETSTypeReferencePart(global.generatedEs2panda._UpdateETSTypeReferencePart(global.context, passNode(original), passNode(name), passNode(typeParams), passNode(prev)))
+        const result: ETSTypeReferencePart = new ETSTypeReferencePart(global.generatedEs2panda._UpdateETSTypeReferencePart(global.context, passNode(original), passNode(name), passNode(typeParams), passNode(prev)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE_PART)
         result.setChildrenParentPtr()
         return result
     }
     static update1ETSTypeReferencePart(original?: ETSTypeReferencePart, name?: Expression): ETSTypeReferencePart {
-        const result: ETSTypeReferencePart = new ETSTypeReferencePart(global.generatedEs2panda._UpdateETSTypeReferencePart1(global.context, passNode(original), passNode(name)))
+        const result: ETSTypeReferencePart = new ETSTypeReferencePart(global.generatedEs2panda._UpdateETSTypeReferencePart1(global.context, passNode(original), passNode(name)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE_PART)
         result.setChildrenParentPtr()
         return result
     }
     get previous(): ETSTypeReferencePart | undefined {
-        return unpackNode(global.generatedEs2panda._ETSTypeReferencePartPrevious(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ETSTypeReferencePartPrevious(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE_PART)
     }
     get name(): Expression | undefined {
         return unpackNode(global.generatedEs2panda._ETSTypeReferencePartName(global.context, this.peer))
     }
     get typeParams(): TSTypeParameterInstantiation | undefined {
-        return unpackNode(global.generatedEs2panda._ETSTypeReferencePartTypeParams(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ETSTypeReferencePartTypeParams(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION)
     }
     get ident(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._ETSTypeReferencePartGetIdent(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ETSTypeReferencePartGetIdent(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)
     }
     protected readonly brandETSTypeReferencePart: undefined
 }
@@ -76,5 +74,5 @@ export function isETSTypeReferencePart(node: object | undefined): node is ETSTyp
     return node instanceof ETSTypeReferencePart
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE_PART)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE_PART, (peer: KNativePointer) => new ETSTypeReferencePart(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE_PART, (peer: KNativePointer) => new ETSTypeReferencePart(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE_PART))
 }

package/build/libarkts-copy/src/generated/peers/ETSUndefinedType.ts

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -36,17 +35,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 
 export class ETSUndefinedType extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 65)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createETSUndefinedType(): ETSUndefinedType {
-        const result: ETSUndefinedType = new ETSUndefinedType(global.generatedEs2panda._CreateETSUndefinedType(global.context))
+        const result: ETSUndefinedType = new ETSUndefinedType(global.generatedEs2panda._CreateETSUndefinedType(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNDEFINED_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static updateETSUndefinedType(original?: ETSUndefinedType): ETSUndefinedType {
-        const result: ETSUndefinedType = new ETSUndefinedType(global.generatedEs2panda._UpdateETSUndefinedType(global.context, passNode(original)))
+        const result: ETSUndefinedType = new ETSUndefinedType(global.generatedEs2panda._UpdateETSUndefinedType(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNDEFINED_TYPE)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +54,5 @@ export function isETSUndefinedType(node: object | undefined): node is ETSUndefin
     return node instanceof ETSUndefinedType
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNDEFINED_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNDEFINED_TYPE, (peer: KNativePointer) => new ETSUndefinedType(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNDEFINED_TYPE, (peer: KNativePointer) => new ETSUndefinedType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNDEFINED_TYPE))
 }

package/build/libarkts-copy/src/generated/peers/ETSUnionType.ts

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,12 +36,11 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 
 export class ETSUnionType extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 76)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createETSUnionType(types: readonly TypeNode[], annotations?: readonly AnnotationUsage[]): ETSUnionType {
-        const result: ETSUnionType = new ETSUnionType(global.generatedEs2panda._CreateETSUnionType(global.context, passNodeArray(types), types.length))
+        const result: ETSUnionType = new ETSUnionType(global.generatedEs2panda._CreateETSUnionType(global.context, passNodeArray(types), types.length), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNION_TYPE)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -51,7 +49,7 @@ export class ETSUnionType extends TypeNode {
         return result
     }
     static updateETSUnionType(original: ETSUnionType | undefined, types: readonly TypeNode[], annotations?: readonly AnnotationUsage[]): ETSUnionType {
-        const result: ETSUnionType = new ETSUnionType(global.generatedEs2panda._UpdateETSUnionType(global.context, passNode(original), passNodeArray(types), types.length))
+        const result: ETSUnionType = new ETSUnionType(global.generatedEs2panda._UpdateETSUnionType(global.context, passNode(original), passNodeArray(types), types.length), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNION_TYPE)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -73,5 +71,5 @@ export function isETSUnionType(node: object | undefined): node is ETSUnionType {
     return node instanceof ETSUnionType
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNION_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNION_TYPE, (peer: KNativePointer) => new ETSUnionType(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNION_TYPE, (peer: KNativePointer) => new ETSUnionType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNION_TYPE))
 }

package/build/libarkts-copy/src/generated/peers/ETSWildcardType.ts

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -38,22 +37,21 @@ import { Es2pandaModifierFlags } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 
 export class ETSWildcardType extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 70)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createETSWildcardType(typeReference: ETSTypeReference | undefined, flags: Es2pandaModifierFlags): ETSWildcardType {
-        const result: ETSWildcardType = new ETSWildcardType(global.generatedEs2panda._CreateETSWildcardType(global.context, passNode(typeReference), flags))
+        const result: ETSWildcardType = new ETSWildcardType(global.generatedEs2panda._CreateETSWildcardType(global.context, passNode(typeReference), flags), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_WILDCARD_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static updateETSWildcardType(original: ETSWildcardType | undefined, typeReference: ETSTypeReference | undefined, flags: Es2pandaModifierFlags): ETSWildcardType {
-        const result: ETSWildcardType = new ETSWildcardType(global.generatedEs2panda._UpdateETSWildcardType(global.context, passNode(original), passNode(typeReference), flags))
+        const result: ETSWildcardType = new ETSWildcardType(global.generatedEs2panda._UpdateETSWildcardType(global.context, passNode(original), passNode(typeReference), flags), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_WILDCARD_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     get typeReference(): ETSTypeReference | undefined {
-        return unpackNode(global.generatedEs2panda._ETSWildcardTypeTypeReference(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ETSWildcardTypeTypeReference(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE)
     }
     protected readonly brandETSWildcardType: undefined
 }
@@ -61,5 +59,5 @@ export function isETSWildcardType(node: object | undefined): node is ETSWildcard
     return node instanceof ETSWildcardType
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_WILDCARD_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_WILDCARD_TYPE, (peer: KNativePointer) => new ETSWildcardType(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_WILDCARD_TYPE, (peer: KNativePointer) => new ETSWildcardType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_WILDCARD_TYPE))
 }

package/build/libarkts-copy/src/generated/peers/EmptyStatement.ts

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -36,22 +35,21 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Statement } from "./Statement"
 
 export class EmptyStatement extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 25)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static create1EmptyStatement(isBrokenStatement: boolean): EmptyStatement {
-        const result: EmptyStatement = new EmptyStatement(global.generatedEs2panda._CreateEmptyStatement1(global.context, isBrokenStatement))
+        const result: EmptyStatement = new EmptyStatement(global.generatedEs2panda._CreateEmptyStatement1(global.context, isBrokenStatement), Es2pandaAstNodeType.AST_NODE_TYPE_EMPTY_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static updateEmptyStatement(original?: EmptyStatement): EmptyStatement {
-        const result: EmptyStatement = new EmptyStatement(global.generatedEs2panda._UpdateEmptyStatement(global.context, passNode(original)))
+        const result: EmptyStatement = new EmptyStatement(global.generatedEs2panda._UpdateEmptyStatement(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_EMPTY_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static update1EmptyStatement(original: EmptyStatement | undefined, isBrokenStatement: boolean): EmptyStatement {
-        const result: EmptyStatement = new EmptyStatement(global.generatedEs2panda._UpdateEmptyStatement1(global.context, passNode(original), isBrokenStatement))
+        const result: EmptyStatement = new EmptyStatement(global.generatedEs2panda._UpdateEmptyStatement1(global.context, passNode(original), isBrokenStatement), Es2pandaAstNodeType.AST_NODE_TYPE_EMPTY_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
@@ -64,5 +62,5 @@ export function isEmptyStatement(node: object | undefined): node is EmptyStateme
     return node instanceof EmptyStatement
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_EMPTY_STATEMENT)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_EMPTY_STATEMENT, (peer: KNativePointer) => new EmptyStatement(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_EMPTY_STATEMENT, (peer: KNativePointer) => new EmptyStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_EMPTY_STATEMENT))
 }

package/build/libarkts-copy/src/generated/peers/ErrorLogger.ts

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,