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

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -36,17 +35,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 
 export class TSInterfaceBody extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 134)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSInterfaceBody(body: readonly AstNode[]): TSInterfaceBody {
-        const result: TSInterfaceBody = new TSInterfaceBody(global.generatedEs2panda._CreateTSInterfaceBody(global.context, passNodeArray(body), body.length))
+        const result: TSInterfaceBody = new TSInterfaceBody(global.generatedEs2panda._CreateTSInterfaceBody(global.context, passNodeArray(body), body.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_BODY)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSInterfaceBody(original: TSInterfaceBody | undefined, body: readonly AstNode[]): TSInterfaceBody {
-        const result: TSInterfaceBody = new TSInterfaceBody(global.generatedEs2panda._UpdateTSInterfaceBody(global.context, passNode(original), passNodeArray(body), body.length))
+        const result: TSInterfaceBody = new TSInterfaceBody(global.generatedEs2panda._UpdateTSInterfaceBody(global.context, passNode(original), passNodeArray(body), body.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_BODY)
         result.setChildrenParentPtr()
         return result
     }
@@ -59,5 +57,5 @@ export function isTSInterfaceBody(node: object | undefined): node is TSInterface
     return node instanceof TSInterfaceBody
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_BODY)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_BODY, (peer: KNativePointer) => new TSInterfaceBody(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_BODY, (peer: KNativePointer) => new TSInterfaceBody(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_BODY))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -34,22 +33,21 @@ import {
 
 import { AnnotationUsage } from "./AnnotationUsage"
 import { ClassDeclaration } from "./ClassDeclaration"
-import { Decorator } from "./Decorator"
 import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Es2pandaModifierFlags } from "./../Es2pandaEnums"
 import { Identifier } from "./Identifier"
+import { SrcDumper } from "./SrcDumper"
 import { TSInterfaceBody } from "./TSInterfaceBody"
 import { TSInterfaceHeritage } from "./TSInterfaceHeritage"
 import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration"
 import { TypedStatement } from "./TypedStatement"
 
 export class TSInterfaceDeclaration extends TypedStatement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 133)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSInterfaceDeclaration(_extends: readonly TSInterfaceHeritage[], id: AstNode | undefined, typeParams: AstNode | undefined, body: AstNode | undefined, isStatic: boolean, isExternal: boolean, modifierFlags?: Es2pandaModifierFlags): TSInterfaceDeclaration {
-        const result: TSInterfaceDeclaration = new TSInterfaceDeclaration(global.generatedEs2panda._CreateTSInterfaceDeclaration(global.context, passNodeArray(_extends), _extends.length, passNode(id), passNode(typeParams), passNode(body), isStatic, isExternal))
+        const result: TSInterfaceDeclaration = new TSInterfaceDeclaration(global.generatedEs2panda._CreateTSInterfaceDeclaration(global.context, passNodeArray(_extends), _extends.length, passNode(id), passNode(typeParams), passNode(body), isStatic, isExternal), Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_DECLARATION)
         if (modifierFlags)
         {
             result.modifierFlags = modifierFlags
@@ -58,7 +56,7 @@ export class TSInterfaceDeclaration extends TypedStatement {
         return result
     }
     static updateTSInterfaceDeclaration(original: TSInterfaceDeclaration | undefined, _extends: readonly TSInterfaceHeritage[], id: AstNode | undefined, typeParams: AstNode | undefined, body: AstNode | undefined, isStatic: boolean, isExternal: boolean, modifierFlags?: Es2pandaModifierFlags): TSInterfaceDeclaration {
-        const result: TSInterfaceDeclaration = new TSInterfaceDeclaration(global.generatedEs2panda._UpdateTSInterfaceDeclaration(global.context, passNode(original), passNodeArray(_extends), _extends.length, passNode(id), passNode(typeParams), passNode(body), isStatic, isExternal))
+        const result: TSInterfaceDeclaration = new TSInterfaceDeclaration(global.generatedEs2panda._UpdateTSInterfaceDeclaration(global.context, passNode(original), passNodeArray(_extends), _extends.length, passNode(id), passNode(typeParams), passNode(body), isStatic, isExternal), Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_DECLARATION)
         if (modifierFlags)
         {
             result.modifierFlags = modifierFlags
@@ -67,10 +65,10 @@ export class TSInterfaceDeclaration extends TypedStatement {
         return result
     }
     get body(): TSInterfaceBody | undefined {
-        return unpackNode(global.generatedEs2panda._TSInterfaceDeclarationBody(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSInterfaceDeclarationBody(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_BODY)
     }
     get id(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._TSInterfaceDeclarationId(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSInterfaceDeclarationId(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)
     }
     get internalName(): string {
         return unpackString(global.generatedEs2panda._TSInterfaceDeclarationInternalNameConst(global.context, this.peer))
@@ -87,13 +85,13 @@ export class TSInterfaceDeclaration extends TypedStatement {
         return global.generatedEs2panda._TSInterfaceDeclarationIsFromExternalConst(global.context, this.peer)
     }
     get typeParams(): TSTypeParameterDeclaration | undefined {
-        return unpackNode(global.generatedEs2panda._TSInterfaceDeclarationTypeParams(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSInterfaceDeclarationTypeParams(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION)
     }
     get extends(): readonly TSInterfaceHeritage[] {
-        return unpackNodeArray(global.generatedEs2panda._TSInterfaceDeclarationExtends(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._TSInterfaceDeclarationExtends(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_HERITAGE)
     }
     get extendsForUpdate(): readonly TSInterfaceHeritage[] {
-        return unpackNodeArray(global.generatedEs2panda._TSInterfaceDeclarationExtendsForUpdate(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._TSInterfaceDeclarationExtendsForUpdate(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_HERITAGE)
     }
     get anonClass(): ClassDeclaration | undefined {
         return unpackNode(global.generatedEs2panda._TSInterfaceDeclarationGetAnonClass(global.context, this.peer))
@@ -118,30 +116,12 @@ export class TSInterfaceDeclaration extends TypedStatement {
         global.generatedEs2panda._TSInterfaceDeclarationSetValueExtends(global.context, this.peer, passNode(_extends), index)
         return this
     }
-    /** @deprecated */
-    emplaceDecorators(decorators?: Decorator): this {
-        global.generatedEs2panda._TSInterfaceDeclarationEmplaceDecorators(global.context, this.peer, passNode(decorators))
-        return this
+    get hasAnnotations(): boolean {
+        return global.generatedEs2panda._TSInterfaceDeclarationHasAnnotationsConst(global.context, this.peer)
     }
     /** @deprecated */
-    clearDecorators(): this {
-        global.generatedEs2panda._TSInterfaceDeclarationClearDecorators(global.context, this.peer)
-        return this
-    }
-    /** @deprecated */
-    setValueDecorators(decorators: Decorator | undefined, index: number): this {
-        global.generatedEs2panda._TSInterfaceDeclarationSetValueDecorators(global.context, this.peer, passNode(decorators), index)
-        return this
-    }
-    get decorators(): readonly Decorator[] {
-        return unpackNodeArray(global.generatedEs2panda._TSInterfaceDeclarationDecorators(global.context, this.peer))
-    }
-    get decoratorsForUpdate(): readonly Decorator[] {
-        return unpackNodeArray(global.generatedEs2panda._TSInterfaceDeclarationDecoratorsForUpdate(global.context, this.peer))
-    }
-    /** @deprecated */
-    emplaceAnnotations(source?: AnnotationUsage): this {
-        global.generatedEs2panda._TSInterfaceDeclarationEmplaceAnnotations(global.context, this.peer, passNode(source))
+    emplaceAnnotation(source?: AnnotationUsage): this {
+        global.generatedEs2panda._TSInterfaceDeclarationEmplaceAnnotation(global.context, this.peer, passNode(source))
         return this
     }
     /** @deprecated */
@@ -150,15 +130,15 @@ export class TSInterfaceDeclaration extends TypedStatement {
         return this
     }
     /** @deprecated */
-    setValueAnnotations(source: AnnotationUsage | undefined, index: number): this {
-        global.generatedEs2panda._TSInterfaceDeclarationSetValueAnnotations(global.context, this.peer, passNode(source), index)
+    dumpAnnotations(dumper?: SrcDumper): this {
+        global.generatedEs2panda._TSInterfaceDeclarationDumpAnnotationsConst(global.context, this.peer, passNode(dumper))
         return this
     }
     get annotationsForUpdate(): readonly AnnotationUsage[] {
-        return unpackNodeArray(global.generatedEs2panda._TSInterfaceDeclarationAnnotationsForUpdate(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._TSInterfaceDeclarationAnnotationsForUpdate(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE)
     }
     get annotations(): readonly AnnotationUsage[] {
-        return unpackNodeArray(global.generatedEs2panda._TSInterfaceDeclarationAnnotations(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._TSInterfaceDeclarationAnnotations(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE)
     }
     /** @deprecated */
     setAnnotations(annotationList: readonly AnnotationUsage[]): this {
@@ -170,16 +150,11 @@ export class TSInterfaceDeclaration extends TypedStatement {
         global.generatedEs2panda._TSInterfaceDeclarationSetAnnotations1(global.context, this.peer, passNodeArray(annotationList), annotationList.length)
         return this
     }
-    /** @deprecated */
-    addAnnotations(annotations?: AnnotationUsage): this {
-        global.generatedEs2panda._TSInterfaceDeclarationAddAnnotations(global.context, this.peer, passNode(annotations))
-        return this
-    }
     protected readonly brandTSInterfaceDeclaration: undefined
 }
 export function isTSInterfaceDeclaration(node: object | undefined): node is TSInterfaceDeclaration {
     return node instanceof TSInterfaceDeclaration
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_DECLARATION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_DECLARATION, (peer: KNativePointer) => new TSInterfaceDeclaration(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_DECLARATION, (peer: KNativePointer) => new TSInterfaceDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_DECLARATION))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,17 +36,16 @@ import { Expression } from "./Expression"
 import { TypeNode } from "./TypeNode"
 
 export class TSInterfaceHeritage extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 135)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSInterfaceHeritage(expr?: TypeNode): TSInterfaceHeritage {
-        const result: TSInterfaceHeritage = new TSInterfaceHeritage(global.generatedEs2panda._CreateTSInterfaceHeritage(global.context, passNode(expr)))
+        const result: TSInterfaceHeritage = new TSInterfaceHeritage(global.generatedEs2panda._CreateTSInterfaceHeritage(global.context, passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_HERITAGE)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSInterfaceHeritage(original?: TSInterfaceHeritage, expr?: TypeNode): TSInterfaceHeritage {
-        const result: TSInterfaceHeritage = new TSInterfaceHeritage(global.generatedEs2panda._UpdateTSInterfaceHeritage(global.context, passNode(original), passNode(expr)))
+        const result: TSInterfaceHeritage = new TSInterfaceHeritage(global.generatedEs2panda._UpdateTSInterfaceHeritage(global.context, passNode(original), passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_HERITAGE)
         result.setChildrenParentPtr()
         return result
     }
@@ -60,5 +58,5 @@ export function isTSInterfaceHeritage(node: object | undefined): node is TSInter
     return node instanceof TSInterfaceHeritage
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_HERITAGE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_HERITAGE, (peer: KNativePointer) => new TSInterfaceHeritage(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_HERITAGE, (peer: KNativePointer) => new TSInterfaceHeritage(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_HERITAGE))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,17 +36,16 @@ import { Expression } from "./Expression"
 import { TypeNode } from "./TypeNode"
 
 export class TSIntersectionType extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 115)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSIntersectionType(types: readonly Expression[]): TSIntersectionType {
-        const result: TSIntersectionType = new TSIntersectionType(global.generatedEs2panda._CreateTSIntersectionType(global.context, passNodeArray(types), types.length))
+        const result: TSIntersectionType = new TSIntersectionType(global.generatedEs2panda._CreateTSIntersectionType(global.context, passNodeArray(types), types.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERSECTION_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSIntersectionType(original: TSIntersectionType | undefined, types: readonly Expression[]): TSIntersectionType {
-        const result: TSIntersectionType = new TSIntersectionType(global.generatedEs2panda._UpdateTSIntersectionType(global.context, passNode(original), passNodeArray(types), types.length))
+        const result: TSIntersectionType = new TSIntersectionType(global.generatedEs2panda._UpdateTSIntersectionType(global.context, passNode(original), passNodeArray(types), types.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERSECTION_TYPE)
         result.setChildrenParentPtr()
         return result
     }
@@ -60,5 +58,5 @@ export function isTSIntersectionType(node: object | undefined): node is TSInters
     return node instanceof TSIntersectionType
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERSECTION_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERSECTION_TYPE, (peer: KNativePointer) => new TSIntersectionType(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERSECTION_TYPE, (peer: KNativePointer) => new TSIntersectionType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERSECTION_TYPE))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,17 +36,16 @@ import { Expression } from "./Expression"
 import { TypeNode } from "./TypeNode"
 
 export class TSLiteralType extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 111)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSLiteralType(literal?: Expression): TSLiteralType {
-        const result: TSLiteralType = new TSLiteralType(global.generatedEs2panda._CreateTSLiteralType(global.context, passNode(literal)))
+        const result: TSLiteralType = new TSLiteralType(global.generatedEs2panda._CreateTSLiteralType(global.context, passNode(literal)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_LITERAL_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSLiteralType(original?: TSLiteralType, literal?: Expression): TSLiteralType {
-        const result: TSLiteralType = new TSLiteralType(global.generatedEs2panda._UpdateTSLiteralType(global.context, passNode(original), passNode(literal)))
+        const result: TSLiteralType = new TSLiteralType(global.generatedEs2panda._UpdateTSLiteralType(global.context, passNode(original), passNode(literal)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_LITERAL_TYPE)
         result.setChildrenParentPtr()
         return result
     }
@@ -60,5 +58,5 @@ export function isTSLiteralType(node: object | undefined): node is TSLiteralType
     return node instanceof TSLiteralType
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_LITERAL_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_LITERAL_TYPE, (peer: KNativePointer) => new TSLiteralType(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_LITERAL_TYPE, (peer: KNativePointer) => new TSLiteralType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_LITERAL_TYPE))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -38,22 +37,21 @@ import { TSTypeParameter } from "./TSTypeParameter"
 import { TypeNode } from "./TypeNode"
 
 export class TSMappedType extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 116)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSMappedType(typeParameter: TSTypeParameter | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: Es2pandaMappedOption, optional_arg: Es2pandaMappedOption): TSMappedType {
-        const result: TSMappedType = new TSMappedType(global.generatedEs2panda._CreateTSMappedType(global.context, passNode(typeParameter), passNode(typeAnnotation), readonly_arg, optional_arg))
+        const result: TSMappedType = new TSMappedType(global.generatedEs2panda._CreateTSMappedType(global.context, passNode(typeParameter), passNode(typeAnnotation), readonly_arg, optional_arg), Es2pandaAstNodeType.AST_NODE_TYPE_TS_MAPPED_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSMappedType(original: TSMappedType | undefined, typeParameter: TSTypeParameter | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: Es2pandaMappedOption, optional_arg: Es2pandaMappedOption): TSMappedType {
-        const result: TSMappedType = new TSMappedType(global.generatedEs2panda._UpdateTSMappedType(global.context, passNode(original), passNode(typeParameter), passNode(typeAnnotation), readonly_arg, optional_arg))
+        const result: TSMappedType = new TSMappedType(global.generatedEs2panda._UpdateTSMappedType(global.context, passNode(original), passNode(typeParameter), passNode(typeAnnotation), readonly_arg, optional_arg), Es2pandaAstNodeType.AST_NODE_TYPE_TS_MAPPED_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     get typeParameter(): TSTypeParameter | undefined {
-        return unpackNode(global.generatedEs2panda._TSMappedTypeTypeParameter(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSMappedTypeTypeParameter(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER)
     }
     get typeAnnotation(): TypeNode | undefined {
         return unpackNode(global.generatedEs2panda._TSMappedTypeTypeAnnotation(global.context, this.peer))
@@ -70,5 +68,5 @@ export function isTSMappedType(node: object | undefined): node is TSMappedType {
     return node instanceof TSMappedType
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_MAPPED_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_MAPPED_TYPE, (peer: KNativePointer) => new TSMappedType(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_MAPPED_TYPE, (peer: KNativePointer) => new TSMappedType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_MAPPED_TYPE))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -39,17 +38,16 @@ import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration"
 import { TypeNode } from "./TypeNode"
 
 export class TSMethodSignature extends AstNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 108)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSMethodSignature(key: Expression | undefined, signature: FunctionSignature | undefined, computed: boolean, optional_arg: boolean): TSMethodSignature {
-        const result: TSMethodSignature = new TSMethodSignature(global.generatedEs2panda._CreateTSMethodSignature(global.context, passNode(key), passNode(signature), computed, optional_arg))
+        const result: TSMethodSignature = new TSMethodSignature(global.generatedEs2panda._CreateTSMethodSignature(global.context, passNode(key), passNode(signature), computed, optional_arg), Es2pandaAstNodeType.AST_NODE_TYPE_TS_METHOD_SIGNATURE)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSMethodSignature(original: TSMethodSignature | undefined, key: Expression | undefined, signature: FunctionSignature | undefined, computed: boolean, optional_arg: boolean): TSMethodSignature {
-        const result: TSMethodSignature = new TSMethodSignature(global.generatedEs2panda._UpdateTSMethodSignature(global.context, passNode(original), passNode(key), passNode(signature), computed, optional_arg))
+        const result: TSMethodSignature = new TSMethodSignature(global.generatedEs2panda._UpdateTSMethodSignature(global.context, passNode(original), passNode(key), passNode(signature), computed, optional_arg), Es2pandaAstNodeType.AST_NODE_TYPE_TS_METHOD_SIGNATURE)
         result.setChildrenParentPtr()
         return result
     }
@@ -57,7 +55,7 @@ export class TSMethodSignature extends AstNode {
         return unpackNode(global.generatedEs2panda._TSMethodSignatureKey(global.context, this.peer))
     }
     get typeParams(): TSTypeParameterDeclaration | undefined {
-        return unpackNode(global.generatedEs2panda._TSMethodSignatureTypeParams(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSMethodSignatureTypeParams(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION)
     }
     get params(): readonly Expression[] {
         return unpackNodeArray(global.generatedEs2panda._TSMethodSignatureParamsConst(global.context, this.peer))
@@ -77,5 +75,5 @@ export function isTSMethodSignature(node: object | undefined): node is TSMethodS
     return node instanceof TSMethodSignature
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_METHOD_SIGNATURE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_METHOD_SIGNATURE, (peer: KNativePointer) => new TSMethodSignature(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_METHOD_SIGNATURE, (peer: KNativePointer) => new TSMethodSignature(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_METHOD_SIGNATURE))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -36,17 +35,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Statement } from "./Statement"
 
 export class TSModuleBlock extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 117)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSModuleBlock(statements: readonly Statement[]): TSModuleBlock {
-        const result: TSModuleBlock = new TSModuleBlock(global.generatedEs2panda._CreateTSModuleBlock(global.context, passNodeArray(statements), statements.length))
+        const result: TSModuleBlock = new TSModuleBlock(global.generatedEs2panda._CreateTSModuleBlock(global.context, passNodeArray(statements), statements.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_MODULE_BLOCK)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSModuleBlock(original: TSModuleBlock | undefined, statements: readonly Statement[]): TSModuleBlock {
-        const result: TSModuleBlock = new TSModuleBlock(global.generatedEs2panda._UpdateTSModuleBlock(global.context, passNode(original), passNodeArray(statements), statements.length))
+        const result: TSModuleBlock = new TSModuleBlock(global.generatedEs2panda._UpdateTSModuleBlock(global.context, passNode(original), passNodeArray(statements), statements.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_MODULE_BLOCK)
         result.setChildrenParentPtr()
         return result
     }
@@ -59,5 +57,5 @@ export function isTSModuleBlock(node: object | undefined): node is TSModuleBlock
     return node instanceof TSModuleBlock
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_MODULE_BLOCK)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_MODULE_BLOCK, (peer: KNativePointer) => new TSModuleBlock(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_MODULE_BLOCK, (peer: KNativePointer) => new TSModuleBlock(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_MODULE_BLOCK))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,17 +36,16 @@ import { Expression } from "./Expression"
 import { Statement } from "./Statement"
 
 export class TSModuleDeclaration extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 125)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSModuleDeclaration(name: Expression | undefined, body: Statement | undefined, declare: boolean, _global: boolean): TSModuleDeclaration {
-        const result: TSModuleDeclaration = new TSModuleDeclaration(global.generatedEs2panda._CreateTSModuleDeclaration(global.context, passNode(name), passNode(body), declare, _global))
+        const result: TSModuleDeclaration = new TSModuleDeclaration(global.generatedEs2panda._CreateTSModuleDeclaration(global.context, passNode(name), passNode(body), declare, _global), Es2pandaAstNodeType.AST_NODE_TYPE_TS_MODULE_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSModuleDeclaration(original: TSModuleDeclaration | undefined, name: Expression | undefined, body: Statement | undefined, declare: boolean, _global: boolean): TSModuleDeclaration {
-        const result: TSModuleDeclaration = new TSModuleDeclaration(global.generatedEs2panda._UpdateTSModuleDeclaration(global.context, passNode(original), passNode(name), passNode(body), declare, _global))
+        const result: TSModuleDeclaration = new TSModuleDeclaration(global.generatedEs2panda._UpdateTSModuleDeclaration(global.context, passNode(original), passNode(name), passNode(body), declare, _global), Es2pandaAstNodeType.AST_NODE_TYPE_TS_MODULE_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
@@ -69,5 +67,5 @@ export function isTSModuleDeclaration(node: object | undefined): node is TSModul
     return node instanceof TSModuleDeclaration
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_MODULE_DECLARATION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_MODULE_DECLARATION, (peer: KNativePointer) => new TSModuleDeclaration(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_MODULE_DECLARATION, (peer: KNativePointer) => new TSModuleDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_MODULE_DECLARATION))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,17 +36,16 @@ import { Expression } from "./Expression"
 import { TypeNode } from "./TypeNode"
 
 export class TSNamedTupleMember extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 137)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSNamedTupleMember(label: Expression | undefined, elementType: TypeNode | undefined, optional_arg: boolean): TSNamedTupleMember {
-        const result: TSNamedTupleMember = new TSNamedTupleMember(global.generatedEs2panda._CreateTSNamedTupleMember(global.context, passNode(label), passNode(elementType), optional_arg))
+        const result: TSNamedTupleMember = new TSNamedTupleMember(global.generatedEs2panda._CreateTSNamedTupleMember(global.context, passNode(label), passNode(elementType), optional_arg), Es2pandaAstNodeType.AST_NODE_TYPE_TS_NAMED_TUPLE_MEMBER)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSNamedTupleMember(original: TSNamedTupleMember | undefined, label: Expression | undefined, elementType: TypeNode | undefined, optional_arg: boolean): TSNamedTupleMember {
-        const result: TSNamedTupleMember = new TSNamedTupleMember(global.generatedEs2panda._UpdateTSNamedTupleMember(global.context, passNode(original), passNode(label), passNode(elementType), optional_arg))
+        const result: TSNamedTupleMember = new TSNamedTupleMember(global.generatedEs2panda._UpdateTSNamedTupleMember(global.context, passNode(original), passNode(label), passNode(elementType), optional_arg), Es2pandaAstNodeType.AST_NODE_TYPE_TS_NAMED_TUPLE_MEMBER)
         result.setChildrenParentPtr()
         return result
     }
@@ -66,5 +64,5 @@ export function isTSNamedTupleMember(node: object | undefined): node is TSNamedT
     return node instanceof TSNamedTupleMember
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_NAMED_TUPLE_MEMBER)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_NAMED_TUPLE_MEMBER, (peer: KNativePointer) => new TSNamedTupleMember(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_NAMED_TUPLE_MEMBER, (peer: KNativePointer) => new TSNamedTupleMember(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_NAMED_TUPLE_MEMBER))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -36,17 +35,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 
 export class TSNeverKeyword extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 101)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSNeverKeyword(): TSNeverKeyword {
-        const result: TSNeverKeyword = new TSNeverKeyword(global.generatedEs2panda._CreateTSNeverKeyword(global.context))
+        const result: TSNeverKeyword = new TSNeverKeyword(global.generatedEs2panda._CreateTSNeverKeyword(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_TS_NEVER_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSNeverKeyword(original?: TSNeverKeyword): TSNeverKeyword {
-        const result: TSNeverKeyword = new TSNeverKeyword(global.generatedEs2panda._UpdateTSNeverKeyword(global.context, passNode(original)))
+        const result: TSNeverKeyword = new TSNeverKeyword(global.generatedEs2panda._UpdateTSNeverKeyword(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_NEVER_KEYWORD)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +54,5 @@ export function isTSNeverKeyword(node: object | undefined): node is TSNeverKeywo
     return node instanceof TSNeverKeyword
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_NEVER_KEYWORD)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_NEVER_KEYWORD, (peer: KNativePointer) => new TSNeverKeyword(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_NEVER_KEYWORD, (peer: KNativePointer) => new TSNeverKeyword(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_NEVER_KEYWORD))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -36,17 +35,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 
 export class TSNonNullExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 102)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSNonNullExpression(expr?: Expression): TSNonNullExpression {
-        const result: TSNonNullExpression = new TSNonNullExpression(global.generatedEs2panda._CreateTSNonNullExpression(global.context, passNode(expr)))
+        const result: TSNonNullExpression = new TSNonNullExpression(global.generatedEs2panda._CreateTSNonNullExpression(global.context, passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_NON_NULL_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSNonNullExpression(original?: TSNonNullExpression, expr?: Expression): TSNonNullExpression {
-        const result: TSNonNullExpression = new TSNonNullExpression(global.generatedEs2panda._UpdateTSNonNullExpression(global.context, passNode(original), passNode(expr)))
+        const result: TSNonNullExpression = new TSNonNullExpression(global.generatedEs2panda._UpdateTSNonNullExpression(global.context, passNode(original), passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_NON_NULL_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -64,5 +62,5 @@ export function isTSNonNullExpression(node: object | undefined): node is TSNonNu
     return node instanceof TSNonNullExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_NON_NULL_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_NON_NULL_EXPRESSION, (peer: KNativePointer) => new TSNonNullExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_NON_NULL_EXPRESSION, (peer: KNativePointer) => new TSNonNullExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_NON_NULL_EXPRESSION))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -36,17 +35,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 
 export class 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 +54,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))
 }