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

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

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 
 export class TSNullKeyword extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 103)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSNullKeyword(): TSNullKeyword {
-        const result: TSNullKeyword = new TSNullKeyword(global.generatedEs2panda._CreateTSNullKeyword(global.context))
+        const result: TSNullKeyword = new TSNullKeyword(global.generatedEs2panda._CreateTSNullKeyword(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_TS_NULL_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSNullKeyword(original?: TSNullKeyword): TSNullKeyword {
-        const result: TSNullKeyword = new TSNullKeyword(global.generatedEs2panda._UpdateTSNullKeyword(global.context, passNode(original)))
+        const result: TSNullKeyword = new TSNullKeyword(global.generatedEs2panda._UpdateTSNullKeyword(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_NULL_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +55,5 @@ export function isTSNullKeyword(node: object | undefined): node is TSNullKeyword
     return node instanceof TSNullKeyword
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_NULL_KEYWORD)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_NULL_KEYWORD, (peer: KNativePointer) => new TSNullKeyword(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_NULL_KEYWORD, (peer: KNativePointer) => new TSNullKeyword(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_NULL_KEYWORD))
 }

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

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 
 export class TSNumberKeyword extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 92)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSNumberKeyword(): TSNumberKeyword {
-        const result: TSNumberKeyword = new TSNumberKeyword(global.generatedEs2panda._CreateTSNumberKeyword(global.context))
+        const result: TSNumberKeyword = new TSNumberKeyword(global.generatedEs2panda._CreateTSNumberKeyword(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_TS_NUMBER_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSNumberKeyword(original?: TSNumberKeyword): TSNumberKeyword {
-        const result: TSNumberKeyword = new TSNumberKeyword(global.generatedEs2panda._UpdateTSNumberKeyword(global.context, passNode(original)))
+        const result: TSNumberKeyword = new TSNumberKeyword(global.generatedEs2panda._UpdateTSNumberKeyword(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_NUMBER_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +55,5 @@ export function isTSNumberKeyword(node: object | undefined): node is TSNumberKey
     return node instanceof TSNumberKeyword
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_NUMBER_KEYWORD)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_NUMBER_KEYWORD, (peer: KNativePointer) => new TSNumberKeyword(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_NUMBER_KEYWORD, (peer: KNativePointer) => new TSNumberKeyword(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_NUMBER_KEYWORD))
 }

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

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 
 export class TSObjectKeyword extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 99)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSObjectKeyword(): TSObjectKeyword {
-        const result: TSObjectKeyword = new TSObjectKeyword(global.generatedEs2panda._CreateTSObjectKeyword(global.context))
+        const result: TSObjectKeyword = new TSObjectKeyword(global.generatedEs2panda._CreateTSObjectKeyword(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_TS_OBJECT_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSObjectKeyword(original?: TSObjectKeyword): TSObjectKeyword {
-        const result: TSObjectKeyword = new TSObjectKeyword(global.generatedEs2panda._UpdateTSObjectKeyword(global.context, passNode(original)))
+        const result: TSObjectKeyword = new TSObjectKeyword(global.generatedEs2panda._UpdateTSObjectKeyword(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_OBJECT_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +55,5 @@ export function isTSObjectKeyword(node: object | undefined): node is TSObjectKey
     return node instanceof TSObjectKeyword
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_OBJECT_KEYWORD)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_OBJECT_KEYWORD, (peer: KNativePointer) => new TSObjectKeyword(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_OBJECT_KEYWORD, (peer: KNativePointer) => new TSObjectKeyword(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_OBJECT_KEYWORD))
 }

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

@@ -37,17 +37,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 
 export class TSParameterProperty extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 124)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSParameterProperty(accessibility: Es2pandaAccessibilityOption, parameter: Expression | undefined, readonly_arg: boolean, isStatic: boolean, isExport: boolean): TSParameterProperty {
-        const result: TSParameterProperty = new TSParameterProperty(global.generatedEs2panda._CreateTSParameterProperty(global.context, accessibility, passNode(parameter), readonly_arg, isStatic, isExport))
+        const result: TSParameterProperty = new TSParameterProperty(global.generatedEs2panda._CreateTSParameterProperty(global.context, accessibility, passNode(parameter), readonly_arg, isStatic, isExport), Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARAMETER_PROPERTY)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSParameterProperty(original: TSParameterProperty | undefined, accessibility: Es2pandaAccessibilityOption, parameter: Expression | undefined, readonly_arg: boolean, isStatic: boolean, isExport: boolean): TSParameterProperty {
-        const result: TSParameterProperty = new TSParameterProperty(global.generatedEs2panda._UpdateTSParameterProperty(global.context, passNode(original), accessibility, passNode(parameter), readonly_arg, isStatic, isExport))
+        const result: TSParameterProperty = new TSParameterProperty(global.generatedEs2panda._UpdateTSParameterProperty(global.context, passNode(original), accessibility, passNode(parameter), readonly_arg, isStatic, isExport), Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARAMETER_PROPERTY)
         result.setChildrenParentPtr()
         return result
     }
@@ -72,5 +71,5 @@ export function isTSParameterProperty(node: object | undefined): node is TSParam
     return node instanceof TSParameterProperty
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARAMETER_PROPERTY)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARAMETER_PROPERTY, (peer: KNativePointer) => new TSParameterProperty(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARAMETER_PROPERTY, (peer: KNativePointer) => new TSParameterProperty(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARAMETER_PROPERTY))
 }

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

@@ -37,17 +37,16 @@ import { Expression } from "./Expression"
 import { TypeNode } from "./TypeNode"
 
 export class TSParenthesizedType extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 110)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSParenthesizedType(type?: TypeNode): TSParenthesizedType {
-        const result: TSParenthesizedType = new TSParenthesizedType(global.generatedEs2panda._CreateTSParenthesizedType(global.context, passNode(type)))
+        const result: TSParenthesizedType = new TSParenthesizedType(global.generatedEs2panda._CreateTSParenthesizedType(global.context, passNode(type)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARENT_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSParenthesizedType(original?: TSParenthesizedType, type?: TypeNode): TSParenthesizedType {
-        const result: TSParenthesizedType = new TSParenthesizedType(global.generatedEs2panda._UpdateTSParenthesizedType(global.context, passNode(original), passNode(type)))
+        const result: TSParenthesizedType = new TSParenthesizedType(global.generatedEs2panda._UpdateTSParenthesizedType(global.context, passNode(original), passNode(type)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARENT_TYPE)
         result.setChildrenParentPtr()
         return result
     }
@@ -60,5 +59,5 @@ export function isTSParenthesizedType(node: object | undefined): node is TSParen
     return node instanceof TSParenthesizedType
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARENT_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARENT_TYPE, (peer: KNativePointer) => new TSParenthesizedType(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARENT_TYPE, (peer: KNativePointer) => new TSParenthesizedType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARENT_TYPE))
 }

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

@@ -38,17 +38,16 @@ import { Expression } from "./Expression"
 import { TypeNode } from "./TypeNode"
 
 export class TSPropertySignature extends AnnotatedAstNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 107)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSPropertySignature(key: Expression | undefined, typeAnnotation: TypeNode | undefined, computed: boolean, optional_arg: boolean, readonly_arg: boolean): TSPropertySignature {
-        const result: TSPropertySignature = new TSPropertySignature(global.generatedEs2panda._CreateTSPropertySignature(global.context, passNode(key), passNode(typeAnnotation), computed, optional_arg, readonly_arg))
+        const result: TSPropertySignature = new TSPropertySignature(global.generatedEs2panda._CreateTSPropertySignature(global.context, passNode(key), passNode(typeAnnotation), computed, optional_arg, readonly_arg), Es2pandaAstNodeType.AST_NODE_TYPE_TS_PROPERTY_SIGNATURE)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSPropertySignature(original: TSPropertySignature | undefined, key: Expression | undefined, typeAnnotation: TypeNode | undefined, computed: boolean, optional_arg: boolean, readonly_arg: boolean): TSPropertySignature {
-        const result: TSPropertySignature = new TSPropertySignature(global.generatedEs2panda._UpdateTSPropertySignature(global.context, passNode(original), passNode(key), passNode(typeAnnotation), computed, optional_arg, readonly_arg))
+        const result: TSPropertySignature = new TSPropertySignature(global.generatedEs2panda._UpdateTSPropertySignature(global.context, passNode(original), passNode(key), passNode(typeAnnotation), computed, optional_arg, readonly_arg), Es2pandaAstNodeType.AST_NODE_TYPE_TS_PROPERTY_SIGNATURE)
         result.setChildrenParentPtr()
         return result
     }
@@ -78,5 +77,5 @@ export function isTSPropertySignature(node: object | undefined): node is TSPrope
     return node instanceof TSPropertySignature
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_PROPERTY_SIGNATURE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_PROPERTY_SIGNATURE, (peer: KNativePointer) => new TSPropertySignature(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_PROPERTY_SIGNATURE, (peer: KNativePointer) => new TSPropertySignature(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_PROPERTY_SIGNATURE))
 }

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

@@ -37,17 +37,16 @@ import { Expression } from "./Expression"
 import { Identifier } from "./Identifier"
 
 export class TSQualifiedName extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 131)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSQualifiedName(left?: Expression, right?: Identifier): TSQualifiedName {
-        const result: TSQualifiedName = new TSQualifiedName(global.generatedEs2panda._CreateTSQualifiedName(global.context, passNode(left), passNode(right)))
+        const result: TSQualifiedName = new TSQualifiedName(global.generatedEs2panda._CreateTSQualifiedName(global.context, passNode(left), passNode(right)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_QUALIFIED_NAME)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSQualifiedName(original?: TSQualifiedName, left?: Expression, right?: Identifier): TSQualifiedName {
-        const result: TSQualifiedName = new TSQualifiedName(global.generatedEs2panda._UpdateTSQualifiedName(global.context, passNode(original), passNode(left), passNode(right)))
+        const result: TSQualifiedName = new TSQualifiedName(global.generatedEs2panda._UpdateTSQualifiedName(global.context, passNode(original), passNode(left), passNode(right)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_QUALIFIED_NAME)
         result.setChildrenParentPtr()
         return result
     }
@@ -69,5 +68,5 @@ export function isTSQualifiedName(node: object | undefined): node is TSQualified
     return node instanceof TSQualifiedName
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_QUALIFIED_NAME)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_QUALIFIED_NAME, (peer: KNativePointer) => new TSQualifiedName(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_QUALIFIED_NAME, (peer: KNativePointer) => new TSQualifiedName(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_QUALIFIED_NAME))
 }

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

@@ -41,17 +41,16 @@ import { TypeNode } from "./TypeNode"
 import { TypedAstNode } from "./TypedAstNode"
 
 export class TSSignatureDeclaration extends TypedAstNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 109)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSSignatureDeclaration(kind: Es2pandaTSSignatureDeclarationKind, signature?: FunctionSignature): TSSignatureDeclaration {
-        const result: TSSignatureDeclaration = new TSSignatureDeclaration(global.generatedEs2panda._CreateTSSignatureDeclaration(global.context, kind, passNode(signature)))
+        const result: TSSignatureDeclaration = new TSSignatureDeclaration(global.generatedEs2panda._CreateTSSignatureDeclaration(global.context, kind, passNode(signature)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_SIGNATURE_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSSignatureDeclaration(original: TSSignatureDeclaration | undefined, kind: Es2pandaTSSignatureDeclarationKind, signature?: FunctionSignature): TSSignatureDeclaration {
-        const result: TSSignatureDeclaration = new TSSignatureDeclaration(global.generatedEs2panda._UpdateTSSignatureDeclaration(global.context, passNode(original), kind, passNode(signature)))
+        const result: TSSignatureDeclaration = new TSSignatureDeclaration(global.generatedEs2panda._UpdateTSSignatureDeclaration(global.context, passNode(original), kind, passNode(signature)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_SIGNATURE_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
@@ -73,5 +72,5 @@ export function isTSSignatureDeclaration(node: object | undefined): node is TSSi
     return node instanceof TSSignatureDeclaration
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_SIGNATURE_DECLARATION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_SIGNATURE_DECLARATION, (peer: KNativePointer) => new TSSignatureDeclaration(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_SIGNATURE_DECLARATION, (peer: KNativePointer) => new TSSignatureDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_SIGNATURE_DECLARATION))
 }

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

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 
 export class TSStringKeyword extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 94)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSStringKeyword(): TSStringKeyword {
-        const result: TSStringKeyword = new TSStringKeyword(global.generatedEs2panda._CreateTSStringKeyword(global.context))
+        const result: TSStringKeyword = new TSStringKeyword(global.generatedEs2panda._CreateTSStringKeyword(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_TS_STRING_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSStringKeyword(original?: TSStringKeyword): TSStringKeyword {
-        const result: TSStringKeyword = new TSStringKeyword(global.generatedEs2panda._UpdateTSStringKeyword(global.context, passNode(original)))
+        const result: TSStringKeyword = new TSStringKeyword(global.generatedEs2panda._UpdateTSStringKeyword(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_STRING_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +55,5 @@ export function isTSStringKeyword(node: object | undefined): node is TSStringKey
     return node instanceof TSStringKeyword
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_STRING_KEYWORD)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_STRING_KEYWORD, (peer: KNativePointer) => new TSStringKeyword(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_STRING_KEYWORD, (peer: KNativePointer) => new TSStringKeyword(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_STRING_KEYWORD))
 }

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

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 
 export class TSThisType extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 118)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSThisType(): TSThisType {
-        const result: TSThisType = new TSThisType(global.generatedEs2panda._CreateTSThisType(global.context))
+        const result: TSThisType = new TSThisType(global.generatedEs2panda._CreateTSThisType(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_TS_THIS_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSThisType(original?: TSThisType): TSThisType {
-        const result: TSThisType = new TSThisType(global.generatedEs2panda._UpdateTSThisType(global.context, passNode(original)))
+        const result: TSThisType = new TSThisType(global.generatedEs2panda._UpdateTSThisType(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_THIS_TYPE)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +55,5 @@ export function isTSThisType(node: object | undefined): node is TSThisType {
     return node instanceof TSThisType
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_THIS_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_THIS_TYPE, (peer: KNativePointer) => new TSThisType(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_THIS_TYPE, (peer: KNativePointer) => new TSThisType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_THIS_TYPE))
 }

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

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 
 export class TSTupleType extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 136)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSTupleType(elementTypes: readonly TypeNode[]): TSTupleType {
-        const result: TSTupleType = new TSTupleType(global.generatedEs2panda._CreateTSTupleType(global.context, passNodeArray(elementTypes), elementTypes.length))
+        const result: TSTupleType = new TSTupleType(global.generatedEs2panda._CreateTSTupleType(global.context, passNodeArray(elementTypes), elementTypes.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TUPLE_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSTupleType(original: TSTupleType | undefined, elementTypes: readonly TypeNode[]): TSTupleType {
-        const result: TSTupleType = new TSTupleType(global.generatedEs2panda._UpdateTSTupleType(global.context, passNode(original), passNodeArray(elementTypes), elementTypes.length))
+        const result: TSTupleType = new TSTupleType(global.generatedEs2panda._UpdateTSTupleType(global.context, passNode(original), passNodeArray(elementTypes), elementTypes.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TUPLE_TYPE)
         result.setChildrenParentPtr()
         return result
     }
@@ -59,5 +58,5 @@ export function isTSTupleType(node: object | undefined): node is TSTupleType {
     return node instanceof TSTupleType
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TUPLE_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TUPLE_TYPE, (peer: KNativePointer) => new TSTupleType(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TUPLE_TYPE, (peer: KNativePointer) => new TSTupleType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TUPLE_TYPE))
 }

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

@@ -42,12 +42,11 @@ import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration"
 import { TypeNode } from "./TypeNode"
 
 export class TSTypeAliasDeclaration extends AnnotatedStatement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 129)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSTypeAliasDeclaration(id?: Identifier, typeParams?: TSTypeParameterDeclaration, typeAnnotation?: TypeNode, annotations?: readonly AnnotationUsage[], modifierFlags?: Es2pandaModifierFlags): TSTypeAliasDeclaration {
-        const result: TSTypeAliasDeclaration = new TSTypeAliasDeclaration(global.generatedEs2panda._CreateTSTypeAliasDeclaration(global.context, passNode(id), passNode(typeParams), passNode(typeAnnotation)))
+        const result: TSTypeAliasDeclaration = new TSTypeAliasDeclaration(global.generatedEs2panda._CreateTSTypeAliasDeclaration(global.context, passNode(id), passNode(typeParams), passNode(typeAnnotation)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ALIAS_DECLARATION)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -60,7 +59,7 @@ export class TSTypeAliasDeclaration extends AnnotatedStatement {
         return result
     }
     static updateTSTypeAliasDeclaration(original?: TSTypeAliasDeclaration, id?: Identifier, typeParams?: TSTypeParameterDeclaration, typeAnnotation?: TypeNode, annotations?: readonly AnnotationUsage[], modifierFlags?: Es2pandaModifierFlags): TSTypeAliasDeclaration {
-        const result: TSTypeAliasDeclaration = new TSTypeAliasDeclaration(global.generatedEs2panda._UpdateTSTypeAliasDeclaration(global.context, passNode(original), passNode(id), passNode(typeParams), passNode(typeAnnotation)))
+        const result: TSTypeAliasDeclaration = new TSTypeAliasDeclaration(global.generatedEs2panda._UpdateTSTypeAliasDeclaration(global.context, passNode(original), passNode(id), passNode(typeParams), passNode(typeAnnotation)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ALIAS_DECLARATION)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -73,7 +72,7 @@ export class TSTypeAliasDeclaration extends AnnotatedStatement {
         return result
     }
     static update1TSTypeAliasDeclaration(original?: TSTypeAliasDeclaration, id?: Identifier, annotations?: readonly AnnotationUsage[], modifierFlags?: Es2pandaModifierFlags): TSTypeAliasDeclaration {
-        const result: TSTypeAliasDeclaration = new TSTypeAliasDeclaration(global.generatedEs2panda._UpdateTSTypeAliasDeclaration1(global.context, passNode(original), passNode(id)))
+        const result: TSTypeAliasDeclaration = new TSTypeAliasDeclaration(global.generatedEs2panda._UpdateTSTypeAliasDeclaration1(global.context, passNode(original), passNode(id)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ALIAS_DECLARATION)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -162,5 +161,5 @@ export function isTSTypeAliasDeclaration(node: object | undefined): node is TSTy
     return node instanceof TSTypeAliasDeclaration
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ALIAS_DECLARATION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ALIAS_DECLARATION, (peer: KNativePointer) => new TSTypeAliasDeclaration(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ALIAS_DECLARATION, (peer: KNativePointer) => new TSTypeAliasDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ALIAS_DECLARATION))
 }

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

@@ -38,17 +38,16 @@ import { Expression } from "./Expression"
 import { TypeNode } from "./TypeNode"
 
 export class TSTypeAssertion extends AnnotatedExpression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 142)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSTypeAssertion(typeAnnotation?: TypeNode, expression?: Expression): TSTypeAssertion {
-        const result: TSTypeAssertion = new TSTypeAssertion(global.generatedEs2panda._CreateTSTypeAssertion(global.context, passNode(typeAnnotation), passNode(expression)))
+        const result: TSTypeAssertion = new TSTypeAssertion(global.generatedEs2panda._CreateTSTypeAssertion(global.context, passNode(typeAnnotation), passNode(expression)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ASSERTION)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSTypeAssertion(original?: TSTypeAssertion, typeAnnotation?: TypeNode, expression?: Expression): TSTypeAssertion {
-        const result: TSTypeAssertion = new TSTypeAssertion(global.generatedEs2panda._UpdateTSTypeAssertion(global.context, passNode(original), passNode(typeAnnotation), passNode(expression)))
+        const result: TSTypeAssertion = new TSTypeAssertion(global.generatedEs2panda._UpdateTSTypeAssertion(global.context, passNode(original), passNode(typeAnnotation), passNode(expression)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ASSERTION)
         result.setChildrenParentPtr()
         return result
     }
@@ -69,5 +68,5 @@ export function isTSTypeAssertion(node: object | undefined): node is TSTypeAsser
     return node instanceof TSTypeAssertion
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ASSERTION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ASSERTION, (peer: KNativePointer) => new TSTypeAssertion(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ASSERTION, (peer: KNativePointer) => new TSTypeAssertion(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ASSERTION))
 }

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

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 
 export class TSTypeLiteral extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 106)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSTypeLiteral(members: readonly AstNode[]): TSTypeLiteral {
-        const result: TSTypeLiteral = new TSTypeLiteral(global.generatedEs2panda._CreateTSTypeLiteral(global.context, passNodeArray(members), members.length))
+        const result: TSTypeLiteral = new TSTypeLiteral(global.generatedEs2panda._CreateTSTypeLiteral(global.context, passNodeArray(members), members.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSTypeLiteral(original: TSTypeLiteral | undefined, members: readonly AstNode[]): TSTypeLiteral {
-        const result: TSTypeLiteral = new TSTypeLiteral(global.generatedEs2panda._UpdateTSTypeLiteral(global.context, passNode(original), passNodeArray(members), members.length))
+        const result: TSTypeLiteral = new TSTypeLiteral(global.generatedEs2panda._UpdateTSTypeLiteral(global.context, passNode(original), passNodeArray(members), members.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
@@ -59,5 +58,5 @@ export function isTSTypeLiteral(node: object | undefined): node is TSTypeLiteral
     return node instanceof TSTypeLiteral
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_LITERAL)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_LITERAL, (peer: KNativePointer) => new TSTypeLiteral(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_LITERAL, (peer: KNativePointer) => new TSTypeLiteral(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_LITERAL))
 }

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

@@ -37,17 +37,16 @@ import { Es2pandaTSOperatorType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 
 export class TSTypeOperator extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 119)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSTypeOperator(type: TypeNode | undefined, operatorType: Es2pandaTSOperatorType): TSTypeOperator {
-        const result: TSTypeOperator = new TSTypeOperator(global.generatedEs2panda._CreateTSTypeOperator(global.context, passNode(type), operatorType))
+        const result: TSTypeOperator = new TSTypeOperator(global.generatedEs2panda._CreateTSTypeOperator(global.context, passNode(type), operatorType), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_OPERATOR)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSTypeOperator(original: TSTypeOperator | undefined, type: TypeNode | undefined, operatorType: Es2pandaTSOperatorType): TSTypeOperator {
-        const result: TSTypeOperator = new TSTypeOperator(global.generatedEs2panda._UpdateTSTypeOperator(global.context, passNode(original), passNode(type), operatorType))
+        const result: TSTypeOperator = new TSTypeOperator(global.generatedEs2panda._UpdateTSTypeOperator(global.context, passNode(original), passNode(type), operatorType), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_OPERATOR)
         result.setChildrenParentPtr()
         return result
     }
@@ -69,5 +68,5 @@ export function isTSTypeOperator(node: object | undefined): node is TSTypeOperat
     return node instanceof TSTypeOperator
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_OPERATOR)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_OPERATOR, (peer: KNativePointer) => new TSTypeOperator(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_OPERATOR, (peer: KNativePointer) => new TSTypeOperator(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_OPERATOR))
 }

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

@@ -40,22 +40,21 @@ import { Identifier } from "./Identifier"
 import { TypeNode } from "./TypeNode"
 
 export class TSTypeParameter extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 120)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static create1TSTypeParameter(name: Identifier | undefined, constraint: TypeNode | undefined, defaultType: TypeNode | undefined, flags: Es2pandaModifierFlags): TSTypeParameter {
-        const result: TSTypeParameter = new TSTypeParameter(global.generatedEs2panda._CreateTSTypeParameter1(global.context, passNode(name), passNode(constraint), passNode(defaultType), flags))
+        const result: TSTypeParameter = new TSTypeParameter(global.generatedEs2panda._CreateTSTypeParameter1(global.context, passNode(name), passNode(constraint), passNode(defaultType), flags), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSTypeParameter(original?: TSTypeParameter, name?: Identifier, constraint?: TypeNode, defaultType?: TypeNode): TSTypeParameter {
-        const result: TSTypeParameter = new TSTypeParameter(global.generatedEs2panda._UpdateTSTypeParameter(global.context, passNode(original), passNode(name), passNode(constraint), passNode(defaultType)))
+        const result: TSTypeParameter = new TSTypeParameter(global.generatedEs2panda._UpdateTSTypeParameter(global.context, passNode(original), passNode(name), passNode(constraint), passNode(defaultType)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER)
         result.setChildrenParentPtr()
         return result
     }
     static update1TSTypeParameter(original: TSTypeParameter | undefined, name: Identifier | undefined, constraint: TypeNode | undefined, defaultType: TypeNode | undefined, flags: Es2pandaModifierFlags): TSTypeParameter {
-        const result: TSTypeParameter = new TSTypeParameter(global.generatedEs2panda._UpdateTSTypeParameter1(global.context, passNode(original), passNode(name), passNode(constraint), passNode(defaultType), flags))
+        const result: TSTypeParameter = new TSTypeParameter(global.generatedEs2panda._UpdateTSTypeParameter1(global.context, passNode(original), passNode(name), passNode(constraint), passNode(defaultType), flags), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER)
         result.setChildrenParentPtr()
         return result
     }
@@ -120,5 +119,5 @@ export function isTSTypeParameter(node: object | undefined): node is TSTypeParam
     return node instanceof TSTypeParameter
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER, (peer: KNativePointer) => new TSTypeParameter(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER, (peer: KNativePointer) => new TSTypeParameter(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER))
 }

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

@@ -37,17 +37,16 @@ import { Expression } from "./Expression"
 import { TSTypeParameter } from "./TSTypeParameter"
 
 export class TSTypeParameterDeclaration extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 121)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSTypeParameterDeclaration(params: readonly TSTypeParameter[], requiredParams: number): TSTypeParameterDeclaration {
-        const result: TSTypeParameterDeclaration = new TSTypeParameterDeclaration(global.generatedEs2panda._CreateTSTypeParameterDeclaration(global.context, passNodeArray(params), params.length, requiredParams))
+        const result: TSTypeParameterDeclaration = new TSTypeParameterDeclaration(global.generatedEs2panda._CreateTSTypeParameterDeclaration(global.context, passNodeArray(params), params.length, requiredParams), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSTypeParameterDeclaration(original: TSTypeParameterDeclaration | undefined, params: readonly TSTypeParameter[], requiredParams: number): TSTypeParameterDeclaration {
-        const result: TSTypeParameterDeclaration = new TSTypeParameterDeclaration(global.generatedEs2panda._UpdateTSTypeParameterDeclaration(global.context, passNode(original), passNodeArray(params), params.length, requiredParams))
+        const result: TSTypeParameterDeclaration = new TSTypeParameterDeclaration(global.generatedEs2panda._UpdateTSTypeParameterDeclaration(global.context, passNode(original), passNodeArray(params), params.length, requiredParams), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
@@ -73,5 +72,5 @@ export function isTSTypeParameterDeclaration(node: object | undefined): node is
     return node instanceof TSTypeParameterDeclaration
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION, (peer: KNativePointer) => new TSTypeParameterDeclaration(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION, (peer: KNativePointer) => new TSTypeParameterDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION))
 }

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

@@ -37,17 +37,16 @@ import { Expression } from "./Expression"
 import { TypeNode } from "./TypeNode"
 
 export class TSTypeParameterInstantiation extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 122)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSTypeParameterInstantiation(params: readonly TypeNode[]): TSTypeParameterInstantiation {
-        const result: TSTypeParameterInstantiation = new TSTypeParameterInstantiation(global.generatedEs2panda._CreateTSTypeParameterInstantiation(global.context, passNodeArray(params), params.length))
+        const result: TSTypeParameterInstantiation = new TSTypeParameterInstantiation(global.generatedEs2panda._CreateTSTypeParameterInstantiation(global.context, passNodeArray(params), params.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSTypeParameterInstantiation(original: TSTypeParameterInstantiation | undefined, params: readonly TypeNode[]): TSTypeParameterInstantiation {
-        const result: TSTypeParameterInstantiation = new TSTypeParameterInstantiation(global.generatedEs2panda._UpdateTSTypeParameterInstantiation(global.context, passNode(original), passNodeArray(params), params.length))
+        const result: TSTypeParameterInstantiation = new TSTypeParameterInstantiation(global.generatedEs2panda._UpdateTSTypeParameterInstantiation(global.context, passNode(original), passNodeArray(params), params.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION)
         result.setChildrenParentPtr()
         return result
     }
@@ -60,5 +59,5 @@ export function isTSTypeParameterInstantiation(node: object | undefined): node i
     return node instanceof TSTypeParameterInstantiation
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION, (peer: KNativePointer) => new TSTypeParameterInstantiation(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION, (peer: KNativePointer) => new TSTypeParameterInstantiation(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION))
 }

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

@@ -37,17 +37,16 @@ import { Expression } from "./Expression"
 import { TypeNode } from "./TypeNode"
 
 export class TSTypePredicate extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 123)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSTypePredicate(parameterName: Expression | undefined, typeAnnotation: TypeNode | undefined, asserts: boolean): TSTypePredicate {
-        const result: TSTypePredicate = new TSTypePredicate(global.generatedEs2panda._CreateTSTypePredicate(global.context, passNode(parameterName), passNode(typeAnnotation), asserts))
+        const result: TSTypePredicate = new TSTypePredicate(global.generatedEs2panda._CreateTSTypePredicate(global.context, passNode(parameterName), passNode(typeAnnotation), asserts), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PREDICATE)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSTypePredicate(original: TSTypePredicate | undefined, parameterName: Expression | undefined, typeAnnotation: TypeNode | undefined, asserts: boolean): TSTypePredicate {
-        const result: TSTypePredicate = new TSTypePredicate(global.generatedEs2panda._UpdateTSTypePredicate(global.context, passNode(original), passNode(parameterName), passNode(typeAnnotation), asserts))
+        const result: TSTypePredicate = new TSTypePredicate(global.generatedEs2panda._UpdateTSTypePredicate(global.context, passNode(original), passNode(parameterName), passNode(typeAnnotation), asserts), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PREDICATE)
         result.setChildrenParentPtr()
         return result
     }
@@ -66,5 +65,5 @@ export function isTSTypePredicate(node: object | undefined): node is TSTypePredi
     return node instanceof TSTypePredicate
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PREDICATE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PREDICATE, (peer: KNativePointer) => new TSTypePredicate(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PREDICATE, (peer: KNativePointer) => new TSTypePredicate(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PREDICATE))
 }

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

@@ -37,17 +37,16 @@ import { Expression } from "./Expression"
 import { TypeNode } from "./TypeNode"
 
 export class TSTypeQuery extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 139)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSTypeQuery(exprName?: Expression): TSTypeQuery {
-        const result: TSTypeQuery = new TSTypeQuery(global.generatedEs2panda._CreateTSTypeQuery(global.context, passNode(exprName)))
+        const result: TSTypeQuery = new TSTypeQuery(global.generatedEs2panda._CreateTSTypeQuery(global.context, passNode(exprName)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_QUERY)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSTypeQuery(original?: TSTypeQuery, exprName?: Expression): TSTypeQuery {
-        const result: TSTypeQuery = new TSTypeQuery(global.generatedEs2panda._UpdateTSTypeQuery(global.context, passNode(original), passNode(exprName)))
+        const result: TSTypeQuery = new TSTypeQuery(global.generatedEs2panda._UpdateTSTypeQuery(global.context, passNode(original), passNode(exprName)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_QUERY)
         result.setChildrenParentPtr()
         return result
     }
@@ -60,5 +59,5 @@ export function isTSTypeQuery(node: object | undefined): node is TSTypeQuery {
     return node instanceof TSTypeQuery
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_QUERY)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_QUERY, (peer: KNativePointer) => new TSTypeQuery(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_QUERY, (peer: KNativePointer) => new TSTypeQuery(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_QUERY))
 }