npm - @idlizer/arktscgen - Versions diffs - 2.1.9-arktscgen-9 → 2.1.10-arktscgen-2 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (263) hide show

package/build/libarkts-copy/src/generated/peers/ETSKeyofType.ts CHANGED Viewed

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 export class ETSKeyofType extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 77)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createETSKeyofType(type?: TypeNode): ETSKeyofType {
-        const result: ETSKeyofType = new ETSKeyofType(global.generatedEs2panda._CreateETSKeyofType(global.context, passNode(type)))
+        const result: ETSKeyofType = new ETSKeyofType(global.generatedEs2panda._CreateETSKeyofType(global.context, passNode(type)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_KEYOF_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static updateETSKeyofType(original?: ETSKeyofType, type?: TypeNode): ETSKeyofType {
-        const result: ETSKeyofType = new ETSKeyofType(global.generatedEs2panda._UpdateETSKeyofType(global.context, passNode(original), passNode(type)))
+        const result: ETSKeyofType = new ETSKeyofType(global.generatedEs2panda._UpdateETSKeyofType(global.context, passNode(original), passNode(type)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_KEYOF_TYPE)
         result.setChildrenParentPtr()
         return result
     }
@@ -59,5 +58,5 @@ export function isETSKeyofType(node: object | undefined): node is ETSKeyofType {
     return node instanceof ETSKeyofType
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_KEYOF_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_KEYOF_TYPE, (peer: KNativePointer) => new ETSKeyofType(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_KEYOF_TYPE, (peer: KNativePointer) => new ETSKeyofType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_KEYOF_TYPE))
 }

package/build/libarkts-copy/src/generated/peers/ETSModule.ts CHANGED Viewed

@@ -43,17 +43,16 @@ import { Statement } from "./Statement"
 import { extension_ETSModuleGetNamespaceFlag } from "./../../reexport-for-generated"
 export class ETSModule extends BlockStatement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 84)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createETSModule(statementList: readonly Statement[], ident: Identifier | undefined, flag: Es2pandaModuleFlag, program?: Program): ETSModule {
-        const result: ETSModule = new ETSModule(global.generatedEs2panda._CreateETSModule(global.context, passNodeArray(statementList), statementList.length, passNode(ident), flag, passNode(program)))
+        const result: ETSModule = new ETSModule(global.generatedEs2panda._CreateETSModule(global.context, passNodeArray(statementList), statementList.length, passNode(ident), flag, passNode(program)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE)
         result.setChildrenParentPtr()
         return result
     }
     static updateETSModule(original: ETSModule | undefined, statementList: readonly Statement[], ident: Identifier | undefined, flag: Es2pandaModuleFlag, program?: Program): ETSModule {
-        const result: ETSModule = new ETSModule(global.generatedEs2panda._UpdateETSModule(global.context, passNode(original), passNodeArray(statementList), statementList.length, passNode(ident), flag, passNode(program)))
+        const result: ETSModule = new ETSModule(global.generatedEs2panda._UpdateETSModule(global.context, passNode(original), passNodeArray(statementList), statementList.length, passNode(ident), flag, passNode(program)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE)
         result.setChildrenParentPtr()
         return result
     }
@@ -128,5 +127,5 @@ export function isETSModule(node: object | undefined): node is ETSModule {
     return node instanceof ETSModule
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE, (peer: KNativePointer) => new ETSModule(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE, (peer: KNativePointer) => new ETSModule(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE))
 }

package/build/libarkts-copy/src/generated/peers/ETSNewArrayInstanceExpression.ts CHANGED Viewed

@@ -37,17 +37,16 @@ import { Expression } from "./Expression"
 import { TypeNode } from "./TypeNode"
 export class ETSNewArrayInstanceExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 78)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createETSNewArrayInstanceExpression(typeReference?: TypeNode, dimension?: Expression): ETSNewArrayInstanceExpression {
-        const result: ETSNewArrayInstanceExpression = new ETSNewArrayInstanceExpression(global.generatedEs2panda._CreateETSNewArrayInstanceExpression(global.context, passNode(typeReference), passNode(dimension)))
+        const result: ETSNewArrayInstanceExpression = new ETSNewArrayInstanceExpression(global.generatedEs2panda._CreateETSNewArrayInstanceExpression(global.context, passNode(typeReference), passNode(dimension)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_ARRAY_INSTANCE_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateETSNewArrayInstanceExpression(original?: ETSNewArrayInstanceExpression, typeReference?: TypeNode, dimension?: Expression): ETSNewArrayInstanceExpression {
-        const result: ETSNewArrayInstanceExpression = new ETSNewArrayInstanceExpression(global.generatedEs2panda._UpdateETSNewArrayInstanceExpression(global.context, passNode(original), passNode(typeReference), passNode(dimension)))
+        const result: ETSNewArrayInstanceExpression = new ETSNewArrayInstanceExpression(global.generatedEs2panda._UpdateETSNewArrayInstanceExpression(global.context, passNode(original), passNode(typeReference), passNode(dimension)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_ARRAY_INSTANCE_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -73,5 +72,5 @@ export function isETSNewArrayInstanceExpression(node: object | undefined): node
     return node instanceof ETSNewArrayInstanceExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_ARRAY_INSTANCE_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_ARRAY_INSTANCE_EXPRESSION, (peer: KNativePointer) => new ETSNewArrayInstanceExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_ARRAY_INSTANCE_EXPRESSION, (peer: KNativePointer) => new ETSNewArrayInstanceExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_ARRAY_INSTANCE_EXPRESSION))
 }

package/build/libarkts-copy/src/generated/peers/ETSNewClassInstanceExpression.ts CHANGED Viewed

@@ -36,22 +36,21 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 export class ETSNewClassInstanceExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 80)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createETSNewClassInstanceExpression(typeReference: Expression | undefined, _arguments: readonly Expression[]): ETSNewClassInstanceExpression {
-        const result: ETSNewClassInstanceExpression = new ETSNewClassInstanceExpression(global.generatedEs2panda._CreateETSNewClassInstanceExpression(global.context, passNode(typeReference), passNodeArray(_arguments), _arguments.length))
+        const result: ETSNewClassInstanceExpression = new ETSNewClassInstanceExpression(global.generatedEs2panda._CreateETSNewClassInstanceExpression(global.context, passNode(typeReference), passNodeArray(_arguments), _arguments.length), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_CLASS_INSTANCE_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateETSNewClassInstanceExpression(original: ETSNewClassInstanceExpression | undefined, typeReference: Expression | undefined, _arguments: readonly Expression[]): ETSNewClassInstanceExpression {
-        const result: ETSNewClassInstanceExpression = new ETSNewClassInstanceExpression(global.generatedEs2panda._UpdateETSNewClassInstanceExpression(global.context, passNode(original), passNode(typeReference), passNodeArray(_arguments), _arguments.length))
+        const result: ETSNewClassInstanceExpression = new ETSNewClassInstanceExpression(global.generatedEs2panda._UpdateETSNewClassInstanceExpression(global.context, passNode(original), passNode(typeReference), passNodeArray(_arguments), _arguments.length), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_CLASS_INSTANCE_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static update1ETSNewClassInstanceExpression(original?: ETSNewClassInstanceExpression, other?: ETSNewClassInstanceExpression): ETSNewClassInstanceExpression {
-        const result: ETSNewClassInstanceExpression = new ETSNewClassInstanceExpression(global.generatedEs2panda._UpdateETSNewClassInstanceExpression1(global.context, passNode(original), passNode(other)))
+        const result: ETSNewClassInstanceExpression = new ETSNewClassInstanceExpression(global.generatedEs2panda._UpdateETSNewClassInstanceExpression1(global.context, passNode(original), passNode(other)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_CLASS_INSTANCE_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -77,5 +76,5 @@ export function isETSNewClassInstanceExpression(node: object | undefined): node
     return node instanceof ETSNewClassInstanceExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_CLASS_INSTANCE_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_CLASS_INSTANCE_EXPRESSION, (peer: KNativePointer) => new ETSNewClassInstanceExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_CLASS_INSTANCE_EXPRESSION, (peer: KNativePointer) => new ETSNewClassInstanceExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_CLASS_INSTANCE_EXPRESSION))
 }

package/build/libarkts-copy/src/generated/peers/ETSNewMultiDimArrayInstanceExpression.ts CHANGED Viewed

@@ -37,22 +37,21 @@ import { Expression } from "./Expression"
 import { TypeNode } from "./TypeNode"
 export class ETSNewMultiDimArrayInstanceExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 79)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createETSNewMultiDimArrayInstanceExpression(typeReference: TypeNode | undefined, dimensions: readonly Expression[]): ETSNewMultiDimArrayInstanceExpression {
-        const result: ETSNewMultiDimArrayInstanceExpression = new ETSNewMultiDimArrayInstanceExpression(global.generatedEs2panda._CreateETSNewMultiDimArrayInstanceExpression(global.context, passNode(typeReference), passNodeArray(dimensions), dimensions.length))
+        const result: ETSNewMultiDimArrayInstanceExpression = new ETSNewMultiDimArrayInstanceExpression(global.generatedEs2panda._CreateETSNewMultiDimArrayInstanceExpression(global.context, passNode(typeReference), passNodeArray(dimensions), dimensions.length), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_MULTI_DIM_ARRAY_INSTANCE_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateETSNewMultiDimArrayInstanceExpression(original: ETSNewMultiDimArrayInstanceExpression | undefined, typeReference: TypeNode | undefined, dimensions: readonly Expression[]): ETSNewMultiDimArrayInstanceExpression {
-        const result: ETSNewMultiDimArrayInstanceExpression = new ETSNewMultiDimArrayInstanceExpression(global.generatedEs2panda._UpdateETSNewMultiDimArrayInstanceExpression(global.context, passNode(original), passNode(typeReference), passNodeArray(dimensions), dimensions.length))
+        const result: ETSNewMultiDimArrayInstanceExpression = new ETSNewMultiDimArrayInstanceExpression(global.generatedEs2panda._UpdateETSNewMultiDimArrayInstanceExpression(global.context, passNode(original), passNode(typeReference), passNodeArray(dimensions), dimensions.length), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_MULTI_DIM_ARRAY_INSTANCE_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static update1ETSNewMultiDimArrayInstanceExpression(original?: ETSNewMultiDimArrayInstanceExpression, other?: ETSNewMultiDimArrayInstanceExpression): ETSNewMultiDimArrayInstanceExpression {
-        const result: ETSNewMultiDimArrayInstanceExpression = new ETSNewMultiDimArrayInstanceExpression(global.generatedEs2panda._UpdateETSNewMultiDimArrayInstanceExpression1(global.context, passNode(original), passNode(other)))
+        const result: ETSNewMultiDimArrayInstanceExpression = new ETSNewMultiDimArrayInstanceExpression(global.generatedEs2panda._UpdateETSNewMultiDimArrayInstanceExpression1(global.context, passNode(original), passNode(other)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_MULTI_DIM_ARRAY_INSTANCE_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -73,5 +72,5 @@ export function isETSNewMultiDimArrayInstanceExpression(node: object | undefined
     return node instanceof ETSNewMultiDimArrayInstanceExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_MULTI_DIM_ARRAY_INSTANCE_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_MULTI_DIM_ARRAY_INSTANCE_EXPRESSION, (peer: KNativePointer) => new ETSNewMultiDimArrayInstanceExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_MULTI_DIM_ARRAY_INSTANCE_EXPRESSION, (peer: KNativePointer) => new ETSNewMultiDimArrayInstanceExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_MULTI_DIM_ARRAY_INSTANCE_EXPRESSION))
 }

package/build/libarkts-copy/src/generated/peers/ETSNullType.ts CHANGED Viewed

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 export class ETSNullType extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 64)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createETSNullType(): ETSNullType {
-        const result: ETSNullType = new ETSNullType(global.generatedEs2panda._CreateETSNullType(global.context))
+        const result: ETSNullType = new ETSNullType(global.generatedEs2panda._CreateETSNullType(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NULL_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static updateETSNullType(original?: ETSNullType): ETSNullType {
-        const result: ETSNullType = new ETSNullType(global.generatedEs2panda._UpdateETSNullType(global.context, passNode(original)))
+        const result: ETSNullType = new ETSNullType(global.generatedEs2panda._UpdateETSNullType(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NULL_TYPE)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +55,5 @@ export function isETSNullType(node: object | undefined): node is ETSNullType {
     return node instanceof ETSNullType
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NULL_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NULL_TYPE, (peer: KNativePointer) => new ETSNullType(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NULL_TYPE, (peer: KNativePointer) => new ETSNullType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NULL_TYPE))
 }

package/build/libarkts-copy/src/generated/peers/ETSPackageDeclaration.ts CHANGED Viewed

@@ -37,17 +37,16 @@ import { Expression } from "./Expression"
 import { Statement } from "./Statement"
 export class ETSPackageDeclaration extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 72)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createETSPackageDeclaration(name?: Expression): ETSPackageDeclaration {
-        const result: ETSPackageDeclaration = new ETSPackageDeclaration(global.generatedEs2panda._CreateETSPackageDeclaration(global.context, passNode(name)))
+        const result: ETSPackageDeclaration = new ETSPackageDeclaration(global.generatedEs2panda._CreateETSPackageDeclaration(global.context, passNode(name)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PACKAGE_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     static updateETSPackageDeclaration(original?: ETSPackageDeclaration, name?: Expression): ETSPackageDeclaration {
-        const result: ETSPackageDeclaration = new ETSPackageDeclaration(global.generatedEs2panda._UpdateETSPackageDeclaration(global.context, passNode(original), passNode(name)))
+        const result: ETSPackageDeclaration = new ETSPackageDeclaration(global.generatedEs2panda._UpdateETSPackageDeclaration(global.context, passNode(original), passNode(name)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PACKAGE_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
@@ -57,5 +56,5 @@ export function isETSPackageDeclaration(node: object | undefined): node is ETSPa
     return node instanceof ETSPackageDeclaration
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PACKAGE_DECLARATION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PACKAGE_DECLARATION, (peer: KNativePointer) => new ETSPackageDeclaration(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PACKAGE_DECLARATION, (peer: KNativePointer) => new ETSPackageDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PACKAGE_DECLARATION))
 }

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

@@ -41,12 +41,11 @@ import { SpreadElement } from "./SpreadElement"
 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)
@@ -188,5 +187,5 @@ export function isETSParameterExpression(node: object | undefined): node is ETSP
     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 CHANGED Viewed

@@ -37,17 +37,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 +59,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 CHANGED Viewed

@@ -37,9 +37,8 @@ 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))
@@ -53,5 +52,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 CHANGED Viewed

@@ -36,17 +36,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 +55,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 CHANGED Viewed

@@ -37,17 +37,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 +56,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 CHANGED Viewed

@@ -36,37 +36,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 +86,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 CHANGED Viewed

@@ -38,17 +38,16 @@ 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
     }
@@ -64,5 +63,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 CHANGED Viewed

@@ -39,22 +39,21 @@ 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
     }
@@ -76,5 +75,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 CHANGED Viewed

@@ -36,17 +36,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 +55,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 CHANGED Viewed

@@ -37,12 +37,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 +50,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 +72,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 CHANGED Viewed

@@ -38,17 +38,16 @@ 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
     }
@@ -61,5 +60,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))
 }