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

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

@@ -37,22 +37,21 @@ import { Expression } from "./Expression"
 import { Statement } from "./Statement"
 
 export class ReturnStatement extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 59)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static create1ReturnStatement(argument?: Expression): ReturnStatement {
-        const result: ReturnStatement = new ReturnStatement(global.generatedEs2panda._CreateReturnStatement1(global.context, passNode(argument)))
+        const result: ReturnStatement = new ReturnStatement(global.generatedEs2panda._CreateReturnStatement1(global.context, passNode(argument)), Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static updateReturnStatement(original?: ReturnStatement): ReturnStatement {
-        const result: ReturnStatement = new ReturnStatement(global.generatedEs2panda._UpdateReturnStatement(global.context, passNode(original)))
+        const result: ReturnStatement = new ReturnStatement(global.generatedEs2panda._UpdateReturnStatement(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static update1ReturnStatement(original?: ReturnStatement, argument?: Expression): ReturnStatement {
-        const result: ReturnStatement = new ReturnStatement(global.generatedEs2panda._UpdateReturnStatement1(global.context, passNode(original), passNode(argument)))
+        const result: ReturnStatement = new ReturnStatement(global.generatedEs2panda._UpdateReturnStatement1(global.context, passNode(original), passNode(argument)), Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
@@ -73,5 +72,5 @@ export function isReturnStatement(node: object | undefined): node is ReturnState
     return node instanceof ReturnStatement
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT, (peer: KNativePointer) => new ReturnStatement(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT, (peer: KNativePointer) => new ReturnStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT))
 }

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

@@ -42,15 +42,17 @@ import { ReturnStatement } from "./ReturnStatement"
 import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration"
 import { TypeNode } from "./TypeNode"
 import { extension_ScriptFunctionGetPreferredReturnTypePointer } from "./../../reexport-for-generated"
+import { extension_ScriptFunctionGetSignaturePointer } from "./../../reexport-for-generated"
+import { extension_ScriptFunctionSetParams } from "./../../reexport-for-generated"
 import { extension_ScriptFunctionSetPreferredReturnTypePointer } from "./../../reexport-for-generated"
+import { extension_ScriptFunctionSetSignaturePointer } from "./../../reexport-for-generated"
 
 export class ScriptFunction extends AstNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 60)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createScriptFunction(databody: AstNode | undefined, datasignature: FunctionSignature | undefined, datafuncFlags: number, dataflags: number, ident?: Identifier, annotations?: readonly AnnotationUsage[]): ScriptFunction {
-        const result: ScriptFunction = new ScriptFunction(global.generatedEs2panda._CreateScriptFunction(global.context, passNode(databody), passNode(datasignature), datafuncFlags, dataflags))
+        const result: ScriptFunction = new ScriptFunction(global.generatedEs2panda._CreateScriptFunction(global.context, passNode(databody), passNode(datasignature), datafuncFlags, dataflags), Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION)
         if (ident)
         {
             result.setIdent(ident)
@@ -63,7 +65,7 @@ export class ScriptFunction extends AstNode {
         return result
     }
     static updateScriptFunction(original: ScriptFunction | undefined, databody: AstNode | undefined, datasignature: FunctionSignature | undefined, datafuncFlags: number, dataflags: number, ident?: Identifier, annotations?: readonly AnnotationUsage[]): ScriptFunction {
-        const result: ScriptFunction = new ScriptFunction(global.generatedEs2panda._UpdateScriptFunction(global.context, passNode(original), passNode(databody), passNode(datasignature), datafuncFlags, dataflags))
+        const result: ScriptFunction = new ScriptFunction(global.generatedEs2panda._UpdateScriptFunction(global.context, passNode(original), passNode(databody), passNode(datasignature), datafuncFlags, dataflags), Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION)
         if (ident)
         {
             result.setIdent(ident)
@@ -214,6 +216,14 @@ export class ScriptFunction extends AstNode {
         return global.generatedEs2panda._ScriptFunctionFormalParamsLengthConst(global.context, this.peer)
     }
     /** @deprecated */
+    setAsyncPairMethod(asyncPairFunction?: ScriptFunction): this {
+        global.generatedEs2panda._ScriptFunctionSetAsyncPairMethod(global.context, this.peer, passNode(asyncPairFunction))
+        return this
+    }
+    get asyncPairMethod(): ScriptFunction | undefined {
+        return unpackNode(global.generatedEs2panda._ScriptFunctionAsyncPairMethod(global.context, this.peer))
+    }
+    /** @deprecated */
     emplaceReturnStatements(returnStatements?: ReturnStatement): this {
         global.generatedEs2panda._ScriptFunctionEmplaceReturnStatements(global.context, this.peer, passNode(returnStatements))
         return this
@@ -282,13 +292,16 @@ export class ScriptFunction extends AstNode {
         global.generatedEs2panda._ScriptFunctionAddAnnotations(global.context, this.peer, passNode(annotations))
         return this
     }
+    getSignaturePointer = extension_ScriptFunctionGetSignaturePointer
+    setSignaturePointer = extension_ScriptFunctionSetSignaturePointer
     getPreferredReturnTypePointer = extension_ScriptFunctionGetPreferredReturnTypePointer
     setPreferredReturnTypePointer = extension_ScriptFunctionSetPreferredReturnTypePointer
+    setParams = extension_ScriptFunctionSetParams
     protected readonly brandScriptFunction: undefined
 }
 export function isScriptFunction(node: object | undefined): node is ScriptFunction {
     return node instanceof ScriptFunction
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION, (peer: KNativePointer) => new ScriptFunction(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION, (peer: KNativePointer) => new ScriptFunction(peer, Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION))
 }

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

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 
 export class SequenceExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 61)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createSequenceExpression(sequence_arg: readonly Expression[]): SequenceExpression {
-        const result: SequenceExpression = new SequenceExpression(global.generatedEs2panda._CreateSequenceExpression(global.context, passNodeArray(sequence_arg), sequence_arg.length))
+        const result: SequenceExpression = new SequenceExpression(global.generatedEs2panda._CreateSequenceExpression(global.context, passNodeArray(sequence_arg), sequence_arg.length), Es2pandaAstNodeType.AST_NODE_TYPE_SEQUENCE_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateSequenceExpression(original: SequenceExpression | undefined, sequence_arg: readonly Expression[]): SequenceExpression {
-        const result: SequenceExpression = new SequenceExpression(global.generatedEs2panda._UpdateSequenceExpression(global.context, passNode(original), passNodeArray(sequence_arg), sequence_arg.length))
+        const result: SequenceExpression = new SequenceExpression(global.generatedEs2panda._UpdateSequenceExpression(global.context, passNode(original), passNodeArray(sequence_arg), sequence_arg.length), Es2pandaAstNodeType.AST_NODE_TYPE_SEQUENCE_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -59,5 +58,5 @@ export function isSequenceExpression(node: object | undefined): node is Sequence
     return node instanceof SequenceExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_SEQUENCE_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SEQUENCE_EXPRESSION, (peer: KNativePointer) => new SequenceExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SEQUENCE_EXPRESSION, (peer: KNativePointer) => new SequenceExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_SEQUENCE_EXPRESSION))
 }

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

@@ -32,10 +32,16 @@ import {
     unpackString
 } from "../../reexport-for-generated"
 
+import { extension_SourcePositionGetCol } from "./../../reexport-for-generated"
+import { extension_SourcePositionGetLine } from "./../../reexport-for-generated"
+import { extension_SourcePositionToString } from "./../../reexport-for-generated"
 
 export class SourcePosition extends ArktsObject {
     constructor(pointer: KNativePointer) {
         super(pointer)
     }
+    getLine = extension_SourcePositionGetLine
+    getCol = extension_SourcePositionGetCol
+    toString = extension_SourcePositionToString
     protected readonly brandSourcePosition: undefined
 }

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

@@ -40,17 +40,16 @@ import { TypeNode } from "./TypeNode"
 import { ValidationInfo } from "./ValidationInfo"
 
 export class SpreadElement extends AnnotatedExpression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 165)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createSpreadElement(nodeType: Es2pandaAstNodeType, argument?: Expression): SpreadElement {
-        const result: SpreadElement = new SpreadElement(global.generatedEs2panda._CreateSpreadElement(global.context, nodeType, passNode(argument)))
+        const result: SpreadElement = new SpreadElement(global.generatedEs2panda._CreateSpreadElement(global.context, nodeType, passNode(argument)), Es2pandaAstNodeType.AST_NODE_TYPE_SPREAD_ELEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static updateSpreadElement(original: SpreadElement | undefined, nodeType: Es2pandaAstNodeType, argument?: Expression): SpreadElement {
-        const result: SpreadElement = new SpreadElement(global.generatedEs2panda._UpdateSpreadElement(global.context, passNode(original), nodeType, passNode(argument)))
+        const result: SpreadElement = new SpreadElement(global.generatedEs2panda._UpdateSpreadElement(global.context, passNode(original), nodeType, passNode(argument)), Es2pandaAstNodeType.AST_NODE_TYPE_SPREAD_ELEMENT)
         result.setChildrenParentPtr()
         return result
     }
@@ -85,5 +84,5 @@ export function isSpreadElement(node: object | undefined): node is SpreadElement
     return node instanceof SpreadElement
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_SPREAD_ELEMENT)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SPREAD_ELEMENT, (peer: KNativePointer) => new SpreadElement(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SPREAD_ELEMENT, (peer: KNativePointer) => new SpreadElement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_SPREAD_ELEMENT))
 }

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

@@ -116,3 +116,6 @@ export class SrcDumper extends ArktsObject {
     }
     protected readonly brandSrcDumper: undefined
 }
+export function isSrcDumper(node: object | undefined): node is SrcDumper {
+    return node instanceof SrcDumper
+}

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

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

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

@@ -36,22 +36,21 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Literal } from "./Literal"
 
 export class StringLiteral extends Literal {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 62)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static create1StringLiteral(str: string): StringLiteral {
-        const result: StringLiteral = new StringLiteral(global.generatedEs2panda._CreateStringLiteral1(global.context, str))
+        const result: StringLiteral = new StringLiteral(global.generatedEs2panda._CreateStringLiteral1(global.context, str), Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
     static updateStringLiteral(original?: StringLiteral): StringLiteral {
-        const result: StringLiteral = new StringLiteral(global.generatedEs2panda._UpdateStringLiteral(global.context, passNode(original)))
+        const result: StringLiteral = new StringLiteral(global.generatedEs2panda._UpdateStringLiteral(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
     static update1StringLiteral(original: StringLiteral | undefined, str: string): StringLiteral {
-        const result: StringLiteral = new StringLiteral(global.generatedEs2panda._UpdateStringLiteral1(global.context, passNode(original), str))
+        const result: StringLiteral = new StringLiteral(global.generatedEs2panda._UpdateStringLiteral1(global.context, passNode(original), str), Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
@@ -64,5 +63,5 @@ export function isStringLiteral(node: object | undefined): node is StringLiteral
     return node instanceof StringLiteral
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL, (peer: KNativePointer) => new StringLiteral(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL, (peer: KNativePointer) => new StringLiteral(peer, Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL))
 }

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

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 
 export class SuperExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 85)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createSuperExpression(): SuperExpression {
-        const result: SuperExpression = new SuperExpression(global.generatedEs2panda._CreateSuperExpression(global.context))
+        const result: SuperExpression = new SuperExpression(global.generatedEs2panda._CreateSuperExpression(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateSuperExpression(original?: SuperExpression): SuperExpression {
-        const result: SuperExpression = new SuperExpression(global.generatedEs2panda._UpdateSuperExpression(global.context, passNode(original)))
+        const result: SuperExpression = new SuperExpression(global.generatedEs2panda._UpdateSuperExpression(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +55,5 @@ export function isSuperExpression(node: object | undefined): node is SuperExpres
     return node instanceof SuperExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION, (peer: KNativePointer) => new SuperExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION, (peer: KNativePointer) => new SuperExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION))
 }

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

@@ -37,17 +37,16 @@ import { Expression } from "./Expression"
 import { Statement } from "./Statement"
 
 export class SwitchCaseStatement extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 87)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createSwitchCaseStatement(test: Expression | undefined, consequent: readonly Statement[]): SwitchCaseStatement {
-        const result: SwitchCaseStatement = new SwitchCaseStatement(global.generatedEs2panda._CreateSwitchCaseStatement(global.context, passNode(test), passNodeArray(consequent), consequent.length))
+        const result: SwitchCaseStatement = new SwitchCaseStatement(global.generatedEs2panda._CreateSwitchCaseStatement(global.context, passNode(test), passNodeArray(consequent), consequent.length), Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_CASE_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static updateSwitchCaseStatement(original: SwitchCaseStatement | undefined, test: Expression | undefined, consequent: readonly Statement[]): SwitchCaseStatement {
-        const result: SwitchCaseStatement = new SwitchCaseStatement(global.generatedEs2panda._UpdateSwitchCaseStatement(global.context, passNode(original), passNode(test), passNodeArray(consequent), consequent.length))
+        const result: SwitchCaseStatement = new SwitchCaseStatement(global.generatedEs2panda._UpdateSwitchCaseStatement(global.context, passNode(original), passNode(test), passNodeArray(consequent), consequent.length), Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_CASE_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
@@ -68,5 +67,5 @@ export function isSwitchCaseStatement(node: object | undefined): node is SwitchC
     return node instanceof SwitchCaseStatement
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_CASE_STATEMENT)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_CASE_STATEMENT, (peer: KNativePointer) => new SwitchCaseStatement(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_CASE_STATEMENT, (peer: KNativePointer) => new SwitchCaseStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_CASE_STATEMENT))
 }

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

@@ -38,17 +38,16 @@ import { Statement } from "./Statement"
 import { SwitchCaseStatement } from "./SwitchCaseStatement"
 
 export class SwitchStatement extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 88)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createSwitchStatement(discriminant: Expression | undefined, cases: readonly SwitchCaseStatement[]): SwitchStatement {
-        const result: SwitchStatement = new SwitchStatement(global.generatedEs2panda._CreateSwitchStatement(global.context, passNode(discriminant), passNodeArray(cases), cases.length))
+        const result: SwitchStatement = new SwitchStatement(global.generatedEs2panda._CreateSwitchStatement(global.context, passNode(discriminant), passNodeArray(cases), cases.length), Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static updateSwitchStatement(original: SwitchStatement | undefined, discriminant: Expression | undefined, cases: readonly SwitchCaseStatement[]): SwitchStatement {
-        const result: SwitchStatement = new SwitchStatement(global.generatedEs2panda._UpdateSwitchStatement(global.context, passNode(original), passNode(discriminant), passNodeArray(cases), cases.length))
+        const result: SwitchStatement = new SwitchStatement(global.generatedEs2panda._UpdateSwitchStatement(global.context, passNode(original), passNode(discriminant), passNodeArray(cases), cases.length), Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
@@ -69,5 +68,5 @@ export function isSwitchStatement(node: object | undefined): node is SwitchState
     return node instanceof SwitchStatement
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_STATEMENT)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_STATEMENT, (peer: KNativePointer) => new SwitchStatement(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_STATEMENT, (peer: KNativePointer) => new SwitchStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_STATEMENT))
 }

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

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 
 export class TSAnyKeyword extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 93)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSAnyKeyword(): TSAnyKeyword {
-        const result: TSAnyKeyword = new TSAnyKeyword(global.generatedEs2panda._CreateTSAnyKeyword(global.context))
+        const result: TSAnyKeyword = new TSAnyKeyword(global.generatedEs2panda._CreateTSAnyKeyword(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_TS_ANY_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSAnyKeyword(original?: TSAnyKeyword): TSAnyKeyword {
-        const result: TSAnyKeyword = new TSAnyKeyword(global.generatedEs2panda._UpdateTSAnyKeyword(global.context, passNode(original)))
+        const result: TSAnyKeyword = new TSAnyKeyword(global.generatedEs2panda._UpdateTSAnyKeyword(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_ANY_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +55,5 @@ export function isTSAnyKeyword(node: object | undefined): node is TSAnyKeyword {
     return node instanceof TSAnyKeyword
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_ANY_KEYWORD)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_ANY_KEYWORD, (peer: KNativePointer) => new TSAnyKeyword(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_ANY_KEYWORD, (peer: KNativePointer) => new TSAnyKeyword(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_ANY_KEYWORD))
 }

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

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 
 export class TSArrayType extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 104)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSArrayType(elementType?: TypeNode): TSArrayType {
-        const result: TSArrayType = new TSArrayType(global.generatedEs2panda._CreateTSArrayType(global.context, passNode(elementType)))
+        const result: TSArrayType = new TSArrayType(global.generatedEs2panda._CreateTSArrayType(global.context, passNode(elementType)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_ARRAY_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSArrayType(original?: TSArrayType, elementType?: TypeNode): TSArrayType {
-        const result: TSArrayType = new TSArrayType(global.generatedEs2panda._UpdateTSArrayType(global.context, passNode(original), passNode(elementType)))
+        const result: TSArrayType = new TSArrayType(global.generatedEs2panda._UpdateTSArrayType(global.context, passNode(original), passNode(elementType)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_ARRAY_TYPE)
         result.setChildrenParentPtr()
         return result
     }
@@ -59,5 +58,5 @@ export function isTSArrayType(node: object | undefined): node is TSArrayType {
     return node instanceof TSArrayType
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_ARRAY_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_ARRAY_TYPE, (peer: KNativePointer) => new TSArrayType(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_ARRAY_TYPE, (peer: KNativePointer) => new TSArrayType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_ARRAY_TYPE))
 }

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

@@ -38,17 +38,16 @@ import { Expression } from "./Expression"
 import { TypeNode } from "./TypeNode"
 
 export class TSAsExpression extends AnnotatedExpression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 140)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSAsExpression(expression: Expression | undefined, typeAnnotation: TypeNode | undefined, isConst: boolean): TSAsExpression {
-        const result: TSAsExpression = new TSAsExpression(global.generatedEs2panda._CreateTSAsExpression(global.context, passNode(expression), passNode(typeAnnotation), isConst))
+        const result: TSAsExpression = new TSAsExpression(global.generatedEs2panda._CreateTSAsExpression(global.context, passNode(expression), passNode(typeAnnotation), isConst), Es2pandaAstNodeType.AST_NODE_TYPE_TS_AS_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSAsExpression(original: TSAsExpression | undefined, expression: Expression | undefined, typeAnnotation: TypeNode | undefined, isConst: boolean): TSAsExpression {
-        const result: TSAsExpression = new TSAsExpression(global.generatedEs2panda._UpdateTSAsExpression(global.context, passNode(original), passNode(expression), passNode(typeAnnotation), isConst))
+        const result: TSAsExpression = new TSAsExpression(global.generatedEs2panda._UpdateTSAsExpression(global.context, passNode(original), passNode(expression), passNode(typeAnnotation), isConst), Es2pandaAstNodeType.AST_NODE_TYPE_TS_AS_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -82,5 +81,5 @@ export function isTSAsExpression(node: object | undefined): node is TSAsExpressi
     return node instanceof TSAsExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_AS_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_AS_EXPRESSION, (peer: KNativePointer) => new TSAsExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_AS_EXPRESSION, (peer: KNativePointer) => new TSAsExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_AS_EXPRESSION))
 }

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

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 
 export class TSBigintKeyword extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 100)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSBigintKeyword(): TSBigintKeyword {
-        const result: TSBigintKeyword = new TSBigintKeyword(global.generatedEs2panda._CreateTSBigintKeyword(global.context))
+        const result: TSBigintKeyword = new TSBigintKeyword(global.generatedEs2panda._CreateTSBigintKeyword(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_TS_BIGINT_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSBigintKeyword(original?: TSBigintKeyword): TSBigintKeyword {
-        const result: TSBigintKeyword = new TSBigintKeyword(global.generatedEs2panda._UpdateTSBigintKeyword(global.context, passNode(original)))
+        const result: TSBigintKeyword = new TSBigintKeyword(global.generatedEs2panda._UpdateTSBigintKeyword(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_BIGINT_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +55,5 @@ export function isTSBigintKeyword(node: object | undefined): node is TSBigintKey
     return node instanceof TSBigintKeyword
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_BIGINT_KEYWORD)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_BIGINT_KEYWORD, (peer: KNativePointer) => new TSBigintKeyword(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_BIGINT_KEYWORD, (peer: KNativePointer) => new TSBigintKeyword(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_BIGINT_KEYWORD))
 }

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

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 
 export class TSBooleanKeyword extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 95)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSBooleanKeyword(): TSBooleanKeyword {
-        const result: TSBooleanKeyword = new TSBooleanKeyword(global.generatedEs2panda._CreateTSBooleanKeyword(global.context))
+        const result: TSBooleanKeyword = new TSBooleanKeyword(global.generatedEs2panda._CreateTSBooleanKeyword(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_TS_BOOLEAN_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSBooleanKeyword(original?: TSBooleanKeyword): TSBooleanKeyword {
-        const result: TSBooleanKeyword = new TSBooleanKeyword(global.generatedEs2panda._UpdateTSBooleanKeyword(global.context, passNode(original)))
+        const result: TSBooleanKeyword = new TSBooleanKeyword(global.generatedEs2panda._UpdateTSBooleanKeyword(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_BOOLEAN_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +55,5 @@ export function isTSBooleanKeyword(node: object | undefined): node is TSBooleanK
     return node instanceof TSBooleanKeyword
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_BOOLEAN_KEYWORD)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_BOOLEAN_KEYWORD, (peer: KNativePointer) => new TSBooleanKeyword(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_BOOLEAN_KEYWORD, (peer: KNativePointer) => new TSBooleanKeyword(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_BOOLEAN_KEYWORD))
 }

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

@@ -37,22 +37,21 @@ import { Expression } from "./Expression"
 import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation"
 
 export class TSClassImplements extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 141)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSClassImplements(expression?: Expression, typeParameters?: TSTypeParameterInstantiation): TSClassImplements {
-        const result: TSClassImplements = new TSClassImplements(global.generatedEs2panda._CreateTSClassImplements(global.context, passNode(expression), passNode(typeParameters)))
+        const result: TSClassImplements = new TSClassImplements(global.generatedEs2panda._CreateTSClassImplements(global.context, passNode(expression), passNode(typeParameters)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_CLASS_IMPLEMENTS)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSClassImplements(original?: TSClassImplements, expression?: Expression, typeParameters?: TSTypeParameterInstantiation): TSClassImplements {
-        const result: TSClassImplements = new TSClassImplements(global.generatedEs2panda._UpdateTSClassImplements(global.context, passNode(original), passNode(expression), passNode(typeParameters)))
+        const result: TSClassImplements = new TSClassImplements(global.generatedEs2panda._UpdateTSClassImplements(global.context, passNode(original), passNode(expression), passNode(typeParameters)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_CLASS_IMPLEMENTS)
         result.setChildrenParentPtr()
         return result
     }
     static update1TSClassImplements(original?: TSClassImplements, expression?: Expression): TSClassImplements {
-        const result: TSClassImplements = new TSClassImplements(global.generatedEs2panda._UpdateTSClassImplements1(global.context, passNode(original), passNode(expression)))
+        const result: TSClassImplements = new TSClassImplements(global.generatedEs2panda._UpdateTSClassImplements1(global.context, passNode(original), passNode(expression)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_CLASS_IMPLEMENTS)
         result.setChildrenParentPtr()
         return result
     }
@@ -68,5 +67,5 @@ export function isTSClassImplements(node: object | undefined): node is TSClassIm
     return node instanceof TSClassImplements
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_CLASS_IMPLEMENTS)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_CLASS_IMPLEMENTS, (peer: KNativePointer) => new TSClassImplements(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_CLASS_IMPLEMENTS, (peer: KNativePointer) => new TSClassImplements(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_CLASS_IMPLEMENTS))
 }

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

@@ -37,17 +37,16 @@ import { Expression } from "./Expression"
 import { TypeNode } from "./TypeNode"
 
 export class TSConditionalType extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 113)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSConditionalType(checkType?: Expression, extendsType?: Expression, trueType?: Expression, falseType?: Expression): TSConditionalType {
-        const result: TSConditionalType = new TSConditionalType(global.generatedEs2panda._CreateTSConditionalType(global.context, passNode(checkType), passNode(extendsType), passNode(trueType), passNode(falseType)))
+        const result: TSConditionalType = new TSConditionalType(global.generatedEs2panda._CreateTSConditionalType(global.context, passNode(checkType), passNode(extendsType), passNode(trueType), passNode(falseType)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_CONDITIONAL_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSConditionalType(original?: TSConditionalType, checkType?: Expression, extendsType?: Expression, trueType?: Expression, falseType?: Expression): TSConditionalType {
-        const result: TSConditionalType = new TSConditionalType(global.generatedEs2panda._UpdateTSConditionalType(global.context, passNode(original), passNode(checkType), passNode(extendsType), passNode(trueType), passNode(falseType)))
+        const result: TSConditionalType = new TSConditionalType(global.generatedEs2panda._UpdateTSConditionalType(global.context, passNode(original), passNode(checkType), passNode(extendsType), passNode(trueType), passNode(falseType)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_CONDITIONAL_TYPE)
         result.setChildrenParentPtr()
         return result
     }
@@ -69,5 +68,5 @@ export function isTSConditionalType(node: object | undefined): node is TSConditi
     return node instanceof TSConditionalType
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_CONDITIONAL_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_CONDITIONAL_TYPE, (peer: KNativePointer) => new TSConditionalType(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_CONDITIONAL_TYPE, (peer: KNativePointer) => new TSConditionalType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_CONDITIONAL_TYPE))
 }

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

@@ -39,17 +39,16 @@ import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration"
 import { TypeNode } from "./TypeNode"
 
 export class TSConstructorType extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 128)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSConstructorType(signature: FunctionSignature | undefined, abstract: boolean): TSConstructorType {
-        const result: TSConstructorType = new TSConstructorType(global.generatedEs2panda._CreateTSConstructorType(global.context, passNode(signature), abstract))
+        const result: TSConstructorType = new TSConstructorType(global.generatedEs2panda._CreateTSConstructorType(global.context, passNode(signature), abstract), Es2pandaAstNodeType.AST_NODE_TYPE_TS_CONSTRUCTOR_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSConstructorType(original: TSConstructorType | undefined, signature: FunctionSignature | undefined, abstract: boolean): TSConstructorType {
-        const result: TSConstructorType = new TSConstructorType(global.generatedEs2panda._UpdateTSConstructorType(global.context, passNode(original), passNode(signature), abstract))
+        const result: TSConstructorType = new TSConstructorType(global.generatedEs2panda._UpdateTSConstructorType(global.context, passNode(original), passNode(signature), abstract), Es2pandaAstNodeType.AST_NODE_TYPE_TS_CONSTRUCTOR_TYPE)
         result.setChildrenParentPtr()
         return result
     }
@@ -71,5 +70,5 @@ export function isTSConstructorType(node: object | undefined): node is TSConstru
     return node instanceof TSConstructorType
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_CONSTRUCTOR_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_CONSTRUCTOR_TYPE, (peer: KNativePointer) => new TSConstructorType(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_CONSTRUCTOR_TYPE, (peer: KNativePointer) => new TSConstructorType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_CONSTRUCTOR_TYPE))
 }

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

@@ -40,22 +40,21 @@ import { TypeNode } from "./TypeNode"
 import { TypedStatement } from "./TypedStatement"
 
 export class TSEnumDeclaration extends TypedStatement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 89)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static create1TSEnumDeclaration(key: Identifier | undefined, members: readonly AstNode[], isConst: boolean, isStatic: boolean, isDeclare: boolean, typeNode?: TypeNode): TSEnumDeclaration {
-        const result: TSEnumDeclaration = new TSEnumDeclaration(global.generatedEs2panda._CreateTSEnumDeclaration1(global.context, passNode(key), passNodeArray(members), members.length, isConst, isStatic, isDeclare, passNode(typeNode)))
+        const result: TSEnumDeclaration = new TSEnumDeclaration(global.generatedEs2panda._CreateTSEnumDeclaration1(global.context, passNode(key), passNodeArray(members), members.length, isConst, isStatic, isDeclare, passNode(typeNode)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSEnumDeclaration(original: TSEnumDeclaration | undefined, key: Identifier | undefined, members: readonly AstNode[], isConst: boolean, isStatic: boolean, isDeclare: boolean): TSEnumDeclaration {
-        const result: TSEnumDeclaration = new TSEnumDeclaration(global.generatedEs2panda._UpdateTSEnumDeclaration(global.context, passNode(original), passNode(key), passNodeArray(members), members.length, isConst, isStatic, isDeclare))
+        const result: TSEnumDeclaration = new TSEnumDeclaration(global.generatedEs2panda._UpdateTSEnumDeclaration(global.context, passNode(original), passNode(key), passNodeArray(members), members.length, isConst, isStatic, isDeclare), Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     static update1TSEnumDeclaration(original: TSEnumDeclaration | undefined, key: Identifier | undefined, members: readonly AstNode[], isConst: boolean, isStatic: boolean, isDeclare: boolean, typeNode?: TypeNode): TSEnumDeclaration {
-        const result: TSEnumDeclaration = new TSEnumDeclaration(global.generatedEs2panda._UpdateTSEnumDeclaration1(global.context, passNode(original), passNode(key), passNodeArray(members), members.length, isConst, isStatic, isDeclare, passNode(typeNode)))
+        const result: TSEnumDeclaration = new TSEnumDeclaration(global.generatedEs2panda._UpdateTSEnumDeclaration1(global.context, passNode(original), passNode(key), passNodeArray(members), members.length, isConst, isStatic, isDeclare, passNode(typeNode)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
@@ -132,5 +131,5 @@ export function isTSEnumDeclaration(node: object | undefined): node is TSEnumDec
     return node instanceof TSEnumDeclaration
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_DECLARATION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_DECLARATION, (peer: KNativePointer) => new TSEnumDeclaration(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_DECLARATION, (peer: KNativePointer) => new TSEnumDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_DECLARATION))
 }