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

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

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 
 export class TSUndefinedKeyword extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 97)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSUndefinedKeyword(): TSUndefinedKeyword {
-        const result: TSUndefinedKeyword = new TSUndefinedKeyword(global.generatedEs2panda._CreateTSUndefinedKeyword(global.context))
+        const result: TSUndefinedKeyword = new TSUndefinedKeyword(global.generatedEs2panda._CreateTSUndefinedKeyword(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNDEFINED_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSUndefinedKeyword(original?: TSUndefinedKeyword): TSUndefinedKeyword {
-        const result: TSUndefinedKeyword = new TSUndefinedKeyword(global.generatedEs2panda._UpdateTSUndefinedKeyword(global.context, passNode(original)))
+        const result: TSUndefinedKeyword = new TSUndefinedKeyword(global.generatedEs2panda._UpdateTSUndefinedKeyword(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNDEFINED_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +55,5 @@ export function isTSUndefinedKeyword(node: object | undefined): node is TSUndefi
     return node instanceof TSUndefinedKeyword
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNDEFINED_KEYWORD)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNDEFINED_KEYWORD, (peer: KNativePointer) => new TSUndefinedKeyword(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNDEFINED_KEYWORD, (peer: KNativePointer) => new TSUndefinedKeyword(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNDEFINED_KEYWORD))
 }

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

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 
 export class TSUnionType extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 105)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSUnionType(types: readonly TypeNode[]): TSUnionType {
-        const result: TSUnionType = new TSUnionType(global.generatedEs2panda._CreateTSUnionType(global.context, passNodeArray(types), types.length))
+        const result: TSUnionType = new TSUnionType(global.generatedEs2panda._CreateTSUnionType(global.context, passNodeArray(types), types.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNION_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSUnionType(original: TSUnionType | undefined, types: readonly TypeNode[]): TSUnionType {
-        const result: TSUnionType = new TSUnionType(global.generatedEs2panda._UpdateTSUnionType(global.context, passNode(original), passNodeArray(types), types.length))
+        const result: TSUnionType = new TSUnionType(global.generatedEs2panda._UpdateTSUnionType(global.context, passNode(original), passNodeArray(types), types.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNION_TYPE)
         result.setChildrenParentPtr()
         return result
     }
@@ -59,5 +58,5 @@ export function isTSUnionType(node: object | undefined): node is TSUnionType {
     return node instanceof TSUnionType
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNION_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNION_TYPE, (peer: KNativePointer) => new TSUnionType(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNION_TYPE, (peer: KNativePointer) => new TSUnionType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNION_TYPE))
 }

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

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 
 export class TSUnknownKeyword extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 98)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSUnknownKeyword(): TSUnknownKeyword {
-        const result: TSUnknownKeyword = new TSUnknownKeyword(global.generatedEs2panda._CreateTSUnknownKeyword(global.context))
+        const result: TSUnknownKeyword = new TSUnknownKeyword(global.generatedEs2panda._CreateTSUnknownKeyword(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNKNOWN_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSUnknownKeyword(original?: TSUnknownKeyword): TSUnknownKeyword {
-        const result: TSUnknownKeyword = new TSUnknownKeyword(global.generatedEs2panda._UpdateTSUnknownKeyword(global.context, passNode(original)))
+        const result: TSUnknownKeyword = new TSUnknownKeyword(global.generatedEs2panda._UpdateTSUnknownKeyword(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNKNOWN_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +55,5 @@ export function isTSUnknownKeyword(node: object | undefined): node is TSUnknownK
     return node instanceof TSUnknownKeyword
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNKNOWN_KEYWORD)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNKNOWN_KEYWORD, (peer: KNativePointer) => new TSUnknownKeyword(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNKNOWN_KEYWORD, (peer: KNativePointer) => new TSUnknownKeyword(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNKNOWN_KEYWORD))
 }

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

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 
 export class TSVoidKeyword extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 96)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSVoidKeyword(): TSVoidKeyword {
-        const result: TSVoidKeyword = new TSVoidKeyword(global.generatedEs2panda._CreateTSVoidKeyword(global.context))
+        const result: TSVoidKeyword = new TSVoidKeyword(global.generatedEs2panda._CreateTSVoidKeyword(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_TS_VOID_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSVoidKeyword(original?: TSVoidKeyword): TSVoidKeyword {
-        const result: TSVoidKeyword = new TSVoidKeyword(global.generatedEs2panda._UpdateTSVoidKeyword(global.context, passNode(original)))
+        const result: TSVoidKeyword = new TSVoidKeyword(global.generatedEs2panda._UpdateTSVoidKeyword(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_VOID_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +55,5 @@ export function isTSVoidKeyword(node: object | undefined): node is TSVoidKeyword
     return node instanceof TSVoidKeyword
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_VOID_KEYWORD)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_VOID_KEYWORD, (peer: KNativePointer) => new TSVoidKeyword(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_VOID_KEYWORD, (peer: KNativePointer) => new TSVoidKeyword(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_VOID_KEYWORD))
 }

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

@@ -38,17 +38,16 @@ import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation"
 import { TemplateLiteral } from "./TemplateLiteral"
 
 export class TaggedTemplateExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 143)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTaggedTemplateExpression(tag?: Expression, quasi?: TemplateLiteral, typeParams?: TSTypeParameterInstantiation): TaggedTemplateExpression {
-        const result: TaggedTemplateExpression = new TaggedTemplateExpression(global.generatedEs2panda._CreateTaggedTemplateExpression(global.context, passNode(tag), passNode(quasi), passNode(typeParams)))
+        const result: TaggedTemplateExpression = new TaggedTemplateExpression(global.generatedEs2panda._CreateTaggedTemplateExpression(global.context, passNode(tag), passNode(quasi), passNode(typeParams)), Es2pandaAstNodeType.AST_NODE_TYPE_TAGGED_TEMPLATE_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateTaggedTemplateExpression(original?: TaggedTemplateExpression, tag?: Expression, quasi?: TemplateLiteral, typeParams?: TSTypeParameterInstantiation): TaggedTemplateExpression {
-        const result: TaggedTemplateExpression = new TaggedTemplateExpression(global.generatedEs2panda._UpdateTaggedTemplateExpression(global.context, passNode(original), passNode(tag), passNode(quasi), passNode(typeParams)))
+        const result: TaggedTemplateExpression = new TaggedTemplateExpression(global.generatedEs2panda._UpdateTaggedTemplateExpression(global.context, passNode(original), passNode(tag), passNode(quasi), passNode(typeParams)), Es2pandaAstNodeType.AST_NODE_TYPE_TAGGED_TEMPLATE_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -67,5 +66,5 @@ export function isTaggedTemplateExpression(node: object | undefined): node is Ta
     return node instanceof TaggedTemplateExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TAGGED_TEMPLATE_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TAGGED_TEMPLATE_EXPRESSION, (peer: KNativePointer) => new TaggedTemplateExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TAGGED_TEMPLATE_EXPRESSION, (peer: KNativePointer) => new TaggedTemplateExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TAGGED_TEMPLATE_EXPRESSION))
 }

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

@@ -36,22 +36,21 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 
 export class TemplateElement extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 144)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static create1TemplateElement(raw: string, cooked: string): TemplateElement {
-        const result: TemplateElement = new TemplateElement(global.generatedEs2panda._CreateTemplateElement1(global.context, raw, cooked))
+        const result: TemplateElement = new TemplateElement(global.generatedEs2panda._CreateTemplateElement1(global.context, raw, cooked), Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_ELEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static updateTemplateElement(original?: TemplateElement): TemplateElement {
-        const result: TemplateElement = new TemplateElement(global.generatedEs2panda._UpdateTemplateElement(global.context, passNode(original)))
+        const result: TemplateElement = new TemplateElement(global.generatedEs2panda._UpdateTemplateElement(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_ELEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static update1TemplateElement(original: TemplateElement | undefined, raw: string, cooked: string): TemplateElement {
-        const result: TemplateElement = new TemplateElement(global.generatedEs2panda._UpdateTemplateElement1(global.context, passNode(original), raw, cooked))
+        const result: TemplateElement = new TemplateElement(global.generatedEs2panda._UpdateTemplateElement1(global.context, passNode(original), raw, cooked), Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_ELEMENT)
         result.setChildrenParentPtr()
         return result
     }
@@ -67,5 +66,5 @@ export function isTemplateElement(node: object | undefined): node is TemplateEle
     return node instanceof TemplateElement
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_ELEMENT)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_ELEMENT, (peer: KNativePointer) => new TemplateElement(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_ELEMENT, (peer: KNativePointer) => new TemplateElement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_ELEMENT))
 }

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

@@ -37,17 +37,16 @@ import { Expression } from "./Expression"
 import { TemplateElement } from "./TemplateElement"
 
 export class TemplateLiteral extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 145)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTemplateLiteral(quasis: readonly TemplateElement[], expressions: readonly Expression[], multilineString: string): TemplateLiteral {
-        const result: TemplateLiteral = new TemplateLiteral(global.generatedEs2panda._CreateTemplateLiteral(global.context, passNodeArray(quasis), quasis.length, passNodeArray(expressions), expressions.length, multilineString))
+        const result: TemplateLiteral = new TemplateLiteral(global.generatedEs2panda._CreateTemplateLiteral(global.context, passNodeArray(quasis), quasis.length, passNodeArray(expressions), expressions.length, multilineString), Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
     static updateTemplateLiteral(original: TemplateLiteral | undefined, quasis: readonly TemplateElement[], expressions: readonly Expression[], multilineString: string): TemplateLiteral {
-        const result: TemplateLiteral = new TemplateLiteral(global.generatedEs2panda._UpdateTemplateLiteral(global.context, passNode(original), passNodeArray(quasis), quasis.length, passNodeArray(expressions), expressions.length, multilineString))
+        const result: TemplateLiteral = new TemplateLiteral(global.generatedEs2panda._UpdateTemplateLiteral(global.context, passNode(original), passNodeArray(quasis), quasis.length, passNodeArray(expressions), expressions.length, multilineString), Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
@@ -66,5 +65,5 @@ export function isTemplateLiteral(node: object | undefined): node is TemplateLit
     return node instanceof TemplateLiteral
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_LITERAL)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_LITERAL, (peer: KNativePointer) => new TemplateLiteral(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_LITERAL, (peer: KNativePointer) => new TemplateLiteral(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_LITERAL))
 }

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

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 
 export class ThisExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 146)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createThisExpression(): ThisExpression {
-        const result: ThisExpression = new ThisExpression(global.generatedEs2panda._CreateThisExpression(global.context))
+        const result: ThisExpression = new ThisExpression(global.generatedEs2panda._CreateThisExpression(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_THIS_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateThisExpression(original?: ThisExpression): ThisExpression {
-        const result: ThisExpression = new ThisExpression(global.generatedEs2panda._UpdateThisExpression(global.context, passNode(original)))
+        const result: ThisExpression = new ThisExpression(global.generatedEs2panda._UpdateThisExpression(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_THIS_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +55,5 @@ export function isThisExpression(node: object | undefined): node is ThisExpressi
     return node instanceof ThisExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_THIS_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_THIS_EXPRESSION, (peer: KNativePointer) => new ThisExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_THIS_EXPRESSION, (peer: KNativePointer) => new ThisExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_THIS_EXPRESSION))
 }

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

@@ -37,17 +37,16 @@ import { Expression } from "./Expression"
 import { Statement } from "./Statement"
 
 export class ThrowStatement extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 148)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createThrowStatement(argument?: Expression): ThrowStatement {
-        const result: ThrowStatement = new ThrowStatement(global.generatedEs2panda._CreateThrowStatement(global.context, passNode(argument)))
+        const result: ThrowStatement = new ThrowStatement(global.generatedEs2panda._CreateThrowStatement(global.context, passNode(argument)), Es2pandaAstNodeType.AST_NODE_TYPE_THROW_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static updateThrowStatement(original?: ThrowStatement, argument?: Expression): ThrowStatement {
-        const result: ThrowStatement = new ThrowStatement(global.generatedEs2panda._UpdateThrowStatement(global.context, passNode(original), passNode(argument)))
+        const result: ThrowStatement = new ThrowStatement(global.generatedEs2panda._UpdateThrowStatement(global.context, passNode(original), passNode(argument)), Es2pandaAstNodeType.AST_NODE_TYPE_THROW_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
@@ -60,5 +59,5 @@ export function isThrowStatement(node: object | undefined): node is ThrowStateme
     return node instanceof ThrowStatement
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_THROW_STATEMENT)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_THROW_STATEMENT, (peer: KNativePointer) => new ThrowStatement(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_THROW_STATEMENT, (peer: KNativePointer) => new ThrowStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_THROW_STATEMENT))
 }

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

@@ -39,22 +39,21 @@ import { LabelPair } from "./LabelPair"
 import { Statement } from "./Statement"
 
 export class TryStatement extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 149)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTryStatement(block: BlockStatement | undefined, catchClauses: readonly CatchClause[], finalizer: BlockStatement | undefined, finalizerInsertionsLabelPair: readonly LabelPair[], finalizerInsertionsStatement: readonly Statement[]): TryStatement {
-        const result: TryStatement = new TryStatement(global.generatedEs2panda._CreateTryStatement(global.context, passNode(block), passNodeArray(catchClauses), catchClauses.length, passNode(finalizer), passNodeArray(finalizerInsertionsLabelPair), finalizerInsertionsLabelPair.length, passNodeArray(finalizerInsertionsStatement), finalizerInsertionsStatement.length))
+        const result: TryStatement = new TryStatement(global.generatedEs2panda._CreateTryStatement(global.context, passNode(block), passNodeArray(catchClauses), catchClauses.length, passNode(finalizer), passNodeArray(finalizerInsertionsLabelPair), finalizerInsertionsLabelPair.length, passNodeArray(finalizerInsertionsStatement), finalizerInsertionsStatement.length), Es2pandaAstNodeType.AST_NODE_TYPE_TRY_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static updateTryStatement(original: TryStatement | undefined, block: BlockStatement | undefined, catchClauses: readonly CatchClause[], finalizer: BlockStatement | undefined, finalizerInsertionsLabelPair: readonly LabelPair[], finalizerInsertionsStatement: readonly Statement[]): TryStatement {
-        const result: TryStatement = new TryStatement(global.generatedEs2panda._UpdateTryStatement(global.context, passNode(original), passNode(block), passNodeArray(catchClauses), catchClauses.length, passNode(finalizer), passNodeArray(finalizerInsertionsLabelPair), finalizerInsertionsLabelPair.length, passNodeArray(finalizerInsertionsStatement), finalizerInsertionsStatement.length))
+        const result: TryStatement = new TryStatement(global.generatedEs2panda._UpdateTryStatement(global.context, passNode(original), passNode(block), passNodeArray(catchClauses), catchClauses.length, passNode(finalizer), passNodeArray(finalizerInsertionsLabelPair), finalizerInsertionsLabelPair.length, passNodeArray(finalizerInsertionsStatement), finalizerInsertionsStatement.length), Es2pandaAstNodeType.AST_NODE_TYPE_TRY_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static update1TryStatement(original?: TryStatement, other?: TryStatement): TryStatement {
-        const result: TryStatement = new TryStatement(global.generatedEs2panda._UpdateTryStatement1(global.context, passNode(original), passNode(other)))
+        const result: TryStatement = new TryStatement(global.generatedEs2panda._UpdateTryStatement1(global.context, passNode(original), passNode(other)), Es2pandaAstNodeType.AST_NODE_TYPE_TRY_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
@@ -87,5 +86,5 @@ export function isTryStatement(node: object | undefined): node is TryStatement {
     return node instanceof TryStatement
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TRY_STATEMENT)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TRY_STATEMENT, (peer: KNativePointer) => new TryStatement(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TRY_STATEMENT, (peer: KNativePointer) => new TryStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TRY_STATEMENT))
 }

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

@@ -33,11 +33,12 @@ import {
 } from "../../reexport-for-generated"
 
 import { AnnotationUsage } from "./AnnotationUsage"
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 
 export class TypeNode extends Expression {
-    constructor(pointer: KNativePointer) {
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     /** @deprecated */
     emplaceAnnotations(source?: AnnotationUsage): this {

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

@@ -32,10 +32,11 @@ import {
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 
 export class TypedAstNode extends AstNode {
-    constructor(pointer: KNativePointer) {
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     protected readonly brandTypedAstNode: undefined
 }

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

@@ -32,11 +32,12 @@ import {
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Statement } from "./Statement"
 
 export class TypedStatement extends Statement {
-    constructor(pointer: KNativePointer) {
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     protected readonly brandTypedStatement: undefined
 }

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

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 
 export class TypeofExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 147)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTypeofExpression(argument?: Expression): TypeofExpression {
-        const result: TypeofExpression = new TypeofExpression(global.generatedEs2panda._CreateTypeofExpression(global.context, passNode(argument)))
+        const result: TypeofExpression = new TypeofExpression(global.generatedEs2panda._CreateTypeofExpression(global.context, passNode(argument)), Es2pandaAstNodeType.AST_NODE_TYPE_TYPEOF_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateTypeofExpression(original?: TypeofExpression, argument?: Expression): TypeofExpression {
-        const result: TypeofExpression = new TypeofExpression(global.generatedEs2panda._UpdateTypeofExpression(global.context, passNode(original), passNode(argument)))
+        const result: TypeofExpression = new TypeofExpression(global.generatedEs2panda._UpdateTypeofExpression(global.context, passNode(original), passNode(argument)), Es2pandaAstNodeType.AST_NODE_TYPE_TYPEOF_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -59,5 +58,5 @@ export function isTypeofExpression(node: object | undefined): node is TypeofExpr
     return node instanceof TypeofExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TYPEOF_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TYPEOF_EXPRESSION, (peer: KNativePointer) => new TypeofExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TYPEOF_EXPRESSION, (peer: KNativePointer) => new TypeofExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TYPEOF_EXPRESSION))
 }

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

@@ -37,17 +37,16 @@ import { Es2pandaTokenType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 
 export class UnaryExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 150)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createUnaryExpression(argument: Expression | undefined, unaryOperator: Es2pandaTokenType): UnaryExpression {
-        const result: UnaryExpression = new UnaryExpression(global.generatedEs2panda._CreateUnaryExpression(global.context, passNode(argument), unaryOperator))
+        const result: UnaryExpression = new UnaryExpression(global.generatedEs2panda._CreateUnaryExpression(global.context, passNode(argument), unaryOperator), Es2pandaAstNodeType.AST_NODE_TYPE_UNARY_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateUnaryExpression(original: UnaryExpression | undefined, argument: Expression | undefined, unaryOperator: Es2pandaTokenType): UnaryExpression {
-        const result: UnaryExpression = new UnaryExpression(global.generatedEs2panda._UpdateUnaryExpression(global.context, passNode(original), passNode(argument), unaryOperator))
+        const result: UnaryExpression = new UnaryExpression(global.generatedEs2panda._UpdateUnaryExpression(global.context, passNode(original), passNode(argument), unaryOperator), Es2pandaAstNodeType.AST_NODE_TYPE_UNARY_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -68,5 +67,5 @@ export function isUnaryExpression(node: object | undefined): node is UnaryExpres
     return node instanceof UnaryExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_UNARY_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_UNARY_EXPRESSION, (peer: KNativePointer) => new UnaryExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_UNARY_EXPRESSION, (peer: KNativePointer) => new UnaryExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_UNARY_EXPRESSION))
 }

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

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Literal } from "./Literal"
 
 export class UndefinedLiteral extends Literal {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 51)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createUndefinedLiteral(): UndefinedLiteral {
-        const result: UndefinedLiteral = new UndefinedLiteral(global.generatedEs2panda._CreateUndefinedLiteral(global.context))
+        const result: UndefinedLiteral = new UndefinedLiteral(global.generatedEs2panda._CreateUndefinedLiteral(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_UNDEFINED_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
     static updateUndefinedLiteral(original?: UndefinedLiteral): UndefinedLiteral {
-        const result: UndefinedLiteral = new UndefinedLiteral(global.generatedEs2panda._UpdateUndefinedLiteral(global.context, passNode(original)))
+        const result: UndefinedLiteral = new UndefinedLiteral(global.generatedEs2panda._UpdateUndefinedLiteral(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_UNDEFINED_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +55,5 @@ export function isUndefinedLiteral(node: object | undefined): node is UndefinedL
     return node instanceof UndefinedLiteral
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_UNDEFINED_LITERAL)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_UNDEFINED_LITERAL, (peer: KNativePointer) => new UndefinedLiteral(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_UNDEFINED_LITERAL, (peer: KNativePointer) => new UndefinedLiteral(peer, Es2pandaAstNodeType.AST_NODE_TYPE_UNDEFINED_LITERAL))
 }

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

@@ -37,17 +37,16 @@ import { Es2pandaTokenType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 
 export class UpdateExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 151)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createUpdateExpression(argument: Expression | undefined, updateOperator: Es2pandaTokenType, isPrefix: boolean): UpdateExpression {
-        const result: UpdateExpression = new UpdateExpression(global.generatedEs2panda._CreateUpdateExpression(global.context, passNode(argument), updateOperator, isPrefix))
+        const result: UpdateExpression = new UpdateExpression(global.generatedEs2panda._CreateUpdateExpression(global.context, passNode(argument), updateOperator, isPrefix), Es2pandaAstNodeType.AST_NODE_TYPE_UPDATE_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateUpdateExpression(original: UpdateExpression | undefined, argument: Expression | undefined, updateOperator: Es2pandaTokenType, isPrefix: boolean): UpdateExpression {
-        const result: UpdateExpression = new UpdateExpression(global.generatedEs2panda._UpdateUpdateExpression(global.context, passNode(original), passNode(argument), updateOperator, isPrefix))
+        const result: UpdateExpression = new UpdateExpression(global.generatedEs2panda._UpdateUpdateExpression(global.context, passNode(original), passNode(argument), updateOperator, isPrefix), Es2pandaAstNodeType.AST_NODE_TYPE_UPDATE_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -66,5 +65,5 @@ export function isUpdateExpression(node: object | undefined): node is UpdateExpr
     return node instanceof UpdateExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_UPDATE_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_UPDATE_EXPRESSION, (peer: KNativePointer) => new UpdateExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_UPDATE_EXPRESSION, (peer: KNativePointer) => new UpdateExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_UPDATE_EXPRESSION))
 }

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

@@ -46,3 +46,6 @@ export class ValidationInfo extends ArktsObject {
     }
     protected readonly brandValidationInfo: undefined
 }
+export function isValidationInfo(node: object | undefined): node is ValidationInfo {
+    return node instanceof ValidationInfo
+}

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

@@ -40,12 +40,11 @@ import { Statement } from "./Statement"
 import { VariableDeclarator } from "./VariableDeclarator"
 
 export class VariableDeclaration extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 152)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createVariableDeclaration(kind: Es2pandaVariableDeclarationKind, declarators: readonly VariableDeclarator[], annotations?: readonly AnnotationUsage[]): VariableDeclaration {
-        const result: VariableDeclaration = new VariableDeclaration(global.generatedEs2panda._CreateVariableDeclaration(global.context, kind, passNodeArray(declarators), declarators.length))
+        const result: VariableDeclaration = new VariableDeclaration(global.generatedEs2panda._CreateVariableDeclaration(global.context, kind, passNodeArray(declarators), declarators.length), Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATION)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -54,7 +53,7 @@ export class VariableDeclaration extends Statement {
         return result
     }
     static updateVariableDeclaration(original: VariableDeclaration | undefined, kind: Es2pandaVariableDeclarationKind, declarators: readonly VariableDeclarator[], annotations?: readonly AnnotationUsage[]): VariableDeclaration {
-        const result: VariableDeclaration = new VariableDeclaration(global.generatedEs2panda._UpdateVariableDeclaration(global.context, passNode(original), kind, passNodeArray(declarators), declarators.length))
+        const result: VariableDeclaration = new VariableDeclaration(global.generatedEs2panda._UpdateVariableDeclaration(global.context, passNode(original), kind, passNodeArray(declarators), declarators.length), Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATION)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -119,5 +118,5 @@ export function isVariableDeclaration(node: object | undefined): node is Variabl
     return node instanceof VariableDeclaration
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATION, (peer: KNativePointer) => new VariableDeclaration(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATION, (peer: KNativePointer) => new VariableDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATION))
 }

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

@@ -38,22 +38,21 @@ import { Expression } from "./Expression"
 import { TypedStatement } from "./TypedStatement"
 
 export class VariableDeclarator extends TypedStatement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 153)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static create1VariableDeclarator(flag: Es2pandaVariableDeclaratorFlag, ident?: Expression, init?: Expression): VariableDeclarator {
-        const result: VariableDeclarator = new VariableDeclarator(global.generatedEs2panda._CreateVariableDeclarator1(global.context, flag, passNode(ident), passNode(init)))
+        const result: VariableDeclarator = new VariableDeclarator(global.generatedEs2panda._CreateVariableDeclarator1(global.context, flag, passNode(ident), passNode(init)), Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATOR)
         result.setChildrenParentPtr()
         return result
     }
     static updateVariableDeclarator(original: VariableDeclarator | undefined, flag: Es2pandaVariableDeclaratorFlag, ident?: Expression): VariableDeclarator {
-        const result: VariableDeclarator = new VariableDeclarator(global.generatedEs2panda._UpdateVariableDeclarator(global.context, passNode(original), flag, passNode(ident)))
+        const result: VariableDeclarator = new VariableDeclarator(global.generatedEs2panda._UpdateVariableDeclarator(global.context, passNode(original), flag, passNode(ident)), Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATOR)
         result.setChildrenParentPtr()
         return result
     }
     static update1VariableDeclarator(original: VariableDeclarator | undefined, flag: Es2pandaVariableDeclaratorFlag, ident?: Expression, init?: Expression): VariableDeclarator {
-        const result: VariableDeclarator = new VariableDeclarator(global.generatedEs2panda._UpdateVariableDeclarator1(global.context, passNode(original), flag, passNode(ident), passNode(init)))
+        const result: VariableDeclarator = new VariableDeclarator(global.generatedEs2panda._UpdateVariableDeclarator1(global.context, passNode(original), flag, passNode(ident), passNode(init)), Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATOR)
         result.setChildrenParentPtr()
         return result
     }
@@ -77,5 +76,5 @@ export function isVariableDeclarator(node: object | undefined): node is Variable
     return node instanceof VariableDeclarator
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATOR)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATOR, (peer: KNativePointer) => new VariableDeclarator(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATOR, (peer: KNativePointer) => new VariableDeclarator(peer, Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATOR))
 }

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

@@ -38,17 +38,16 @@ import { LoopStatement } from "./LoopStatement"
 import { Statement } from "./Statement"
 
 export class WhileStatement extends LoopStatement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 154)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createWhileStatement(test?: Expression, body?: Statement): WhileStatement {
-        const result: WhileStatement = new WhileStatement(global.generatedEs2panda._CreateWhileStatement(global.context, passNode(test), passNode(body)))
+        const result: WhileStatement = new WhileStatement(global.generatedEs2panda._CreateWhileStatement(global.context, passNode(test), passNode(body)), Es2pandaAstNodeType.AST_NODE_TYPE_WHILE_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static updateWhileStatement(original?: WhileStatement, test?: Expression, body?: Statement): WhileStatement {
-        const result: WhileStatement = new WhileStatement(global.generatedEs2panda._UpdateWhileStatement(global.context, passNode(original), passNode(test), passNode(body)))
+        const result: WhileStatement = new WhileStatement(global.generatedEs2panda._UpdateWhileStatement(global.context, passNode(original), passNode(test), passNode(body)), Es2pandaAstNodeType.AST_NODE_TYPE_WHILE_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
@@ -69,5 +68,5 @@ export function isWhileStatement(node: object | undefined): node is WhileStateme
     return node instanceof WhileStatement
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_WHILE_STATEMENT)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_WHILE_STATEMENT, (peer: KNativePointer) => new WhileStatement(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_WHILE_STATEMENT, (peer: KNativePointer) => new WhileStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_WHILE_STATEMENT))
 }

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

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 
 export class YieldExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 155)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createYieldExpression(argument: Expression | undefined, isDelegate: boolean): YieldExpression {
-        const result: YieldExpression = new YieldExpression(global.generatedEs2panda._CreateYieldExpression(global.context, passNode(argument), isDelegate))
+        const result: YieldExpression = new YieldExpression(global.generatedEs2panda._CreateYieldExpression(global.context, passNode(argument), isDelegate), Es2pandaAstNodeType.AST_NODE_TYPE_YIELD_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateYieldExpression(original: YieldExpression | undefined, argument: Expression | undefined, isDelegate: boolean): YieldExpression {
-        const result: YieldExpression = new YieldExpression(global.generatedEs2panda._UpdateYieldExpression(global.context, passNode(original), passNode(argument), isDelegate))
+        const result: YieldExpression = new YieldExpression(global.generatedEs2panda._UpdateYieldExpression(global.context, passNode(original), passNode(argument), isDelegate), Es2pandaAstNodeType.AST_NODE_TYPE_YIELD_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -62,5 +61,5 @@ export function isYieldExpression(node: object | undefined): node is YieldExpres
     return node instanceof YieldExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_YIELD_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_YIELD_EXPRESSION, (peer: KNativePointer) => new YieldExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_YIELD_EXPRESSION, (peer: KNativePointer) => new YieldExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_YIELD_EXPRESSION))
 }