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

package/build/libarkts-copy/src/generated/peers/TSBigintKeyword.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 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 +54,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

@@ -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 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 +54,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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,22 +36,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
     }
@@ -60,7 +58,7 @@ export class TSClassImplements extends Expression {
         return unpackNode(global.generatedEs2panda._TSClassImplementsExpr(global.context, this.peer))
     }
     get typeParameters(): TSTypeParameterInstantiation | undefined {
-        return unpackNode(global.generatedEs2panda._TSClassImplementsTypeParametersConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSClassImplementsTypeParametersConst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION)
     }
     protected readonly brandTSClassImplements: undefined
 }
@@ -68,5 +66,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

@@ -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 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 +67,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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -39,22 +38,21 @@ 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
     }
     get typeParams(): TSTypeParameterDeclaration | undefined {
-        return unpackNode(global.generatedEs2panda._TSConstructorTypeTypeParams(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSConstructorTypeTypeParams(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION)
     }
     get params(): readonly Expression[] {
         return unpackNodeArray(global.generatedEs2panda._TSConstructorTypeParamsConst(global.context, this.peer))
@@ -71,5 +69,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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -33,29 +32,27 @@ import {
 } from "../../reexport-for-generated"
 
 import { ClassDefinition } from "./ClassDefinition"
-import { Decorator } from "./Decorator"
 import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Identifier } from "./Identifier"
 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
     }
@@ -63,7 +60,7 @@ export class TSEnumDeclaration extends TypedStatement {
         return unpackNode(global.generatedEs2panda._TSEnumDeclarationTypeNodes(global.context, this.peer))
     }
     get key(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._TSEnumDeclarationKey(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSEnumDeclarationKey(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)
     }
     get members(): readonly AstNode[] {
         return unpackNodeArray(global.generatedEs2panda._TSEnumDeclarationMembersConst(global.context, this.peer))
@@ -77,7 +74,7 @@ export class TSEnumDeclaration extends TypedStatement {
         return this
     }
     get boxedClass(): ClassDefinition | undefined {
-        return unpackNode(global.generatedEs2panda._TSEnumDeclarationBoxedClassConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSEnumDeclarationBoxedClassConst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION)
     }
     /** @deprecated */
     setBoxedClass(boxedClass?: ClassDefinition): this {
@@ -87,27 +84,6 @@ export class TSEnumDeclaration extends TypedStatement {
     get isConst(): boolean {
         return global.generatedEs2panda._TSEnumDeclarationIsConstConst(global.context, this.peer)
     }
-    get decorators(): readonly Decorator[] {
-        return unpackNodeArray(global.generatedEs2panda._TSEnumDeclarationDecoratorsConst(global.context, this.peer))
-    }
-    /** @deprecated */
-    emplaceDecorators(source?: Decorator): this {
-        global.generatedEs2panda._TSEnumDeclarationEmplaceDecorators(global.context, this.peer, passNode(source))
-        return this
-    }
-    /** @deprecated */
-    clearDecorators(): this {
-        global.generatedEs2panda._TSEnumDeclarationClearDecorators(global.context, this.peer)
-        return this
-    }
-    /** @deprecated */
-    setValueDecorators(source: Decorator | undefined, index: number): this {
-        global.generatedEs2panda._TSEnumDeclarationSetValueDecorators(global.context, this.peer, passNode(source), index)
-        return this
-    }
-    get decoratorsForUpdate(): readonly Decorator[] {
-        return unpackNodeArray(global.generatedEs2panda._TSEnumDeclarationDecoratorsForUpdate(global.context, this.peer))
-    }
     /** @deprecated */
     emplaceMembers(source?: AstNode): this {
         global.generatedEs2panda._TSEnumDeclarationEmplaceMembers(global.context, this.peer, passNode(source))
@@ -132,5 +108,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))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,22 +36,21 @@ import { Expression } from "./Expression"
 import { Statement } from "./Statement"
 
 export class TSEnumMember extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 90)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static create1TSEnumMember(key: Expression | undefined, init: Expression | undefined, isGenerated: boolean): TSEnumMember {
-        const result: TSEnumMember = new TSEnumMember(global.generatedEs2panda._CreateTSEnumMember1(global.context, passNode(key), passNode(init), isGenerated))
+        const result: TSEnumMember = new TSEnumMember(global.generatedEs2panda._CreateTSEnumMember1(global.context, passNode(key), passNode(init), isGenerated), Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_MEMBER)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSEnumMember(original?: TSEnumMember, key?: Expression, init?: Expression): TSEnumMember {
-        const result: TSEnumMember = new TSEnumMember(global.generatedEs2panda._UpdateTSEnumMember(global.context, passNode(original), passNode(key), passNode(init)))
+        const result: TSEnumMember = new TSEnumMember(global.generatedEs2panda._UpdateTSEnumMember(global.context, passNode(original), passNode(key), passNode(init)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_MEMBER)
         result.setChildrenParentPtr()
         return result
     }
     static update1TSEnumMember(original: TSEnumMember | undefined, key: Expression | undefined, init: Expression | undefined, isGenerated: boolean): TSEnumMember {
-        const result: TSEnumMember = new TSEnumMember(global.generatedEs2panda._UpdateTSEnumMember1(global.context, passNode(original), passNode(key), passNode(init), isGenerated))
+        const result: TSEnumMember = new TSEnumMember(global.generatedEs2panda._UpdateTSEnumMember1(global.context, passNode(original), passNode(key), passNode(init), isGenerated), Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_MEMBER)
         result.setChildrenParentPtr()
         return result
     }
@@ -74,5 +72,5 @@ export function isTSEnumMember(node: object | undefined): node is TSEnumMember {
     return node instanceof TSEnumMember
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_MEMBER)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_MEMBER, (peer: KNativePointer) => new TSEnumMember(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_MEMBER, (peer: KNativePointer) => new TSEnumMember(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_MEMBER))
 }

package/build/libarkts-copy/src/generated/peers/TSExternalModuleReference.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 TSExternalModuleReference extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 91)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSExternalModuleReference(expr?: Expression): TSExternalModuleReference {
-        const result: TSExternalModuleReference = new TSExternalModuleReference(global.generatedEs2panda._CreateTSExternalModuleReference(global.context, passNode(expr)))
+        const result: TSExternalModuleReference = new TSExternalModuleReference(global.generatedEs2panda._CreateTSExternalModuleReference(global.context, passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_EXTERNAL_MODULE_REFERENCE)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSExternalModuleReference(original?: TSExternalModuleReference, expr?: Expression): TSExternalModuleReference {
-        const result: TSExternalModuleReference = new TSExternalModuleReference(global.generatedEs2panda._UpdateTSExternalModuleReference(global.context, passNode(original), passNode(expr)))
+        const result: TSExternalModuleReference = new TSExternalModuleReference(global.generatedEs2panda._UpdateTSExternalModuleReference(global.context, passNode(original), passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_EXTERNAL_MODULE_REFERENCE)
         result.setChildrenParentPtr()
         return result
     }
@@ -59,5 +57,5 @@ export function isTSExternalModuleReference(node: object | undefined): node is T
     return node instanceof TSExternalModuleReference
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_EXTERNAL_MODULE_REFERENCE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_EXTERNAL_MODULE_REFERENCE, (peer: KNativePointer) => new TSExternalModuleReference(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_EXTERNAL_MODULE_REFERENCE, (peer: KNativePointer) => new TSExternalModuleReference(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_EXTERNAL_MODULE_REFERENCE))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -39,22 +38,21 @@ import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration"
 import { TypeNode } from "./TypeNode"
 
 export class TSFunctionType extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 127)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSFunctionType(signature?: FunctionSignature): TSFunctionType {
-        const result: TSFunctionType = new TSFunctionType(global.generatedEs2panda._CreateTSFunctionType(global.context, passNode(signature)))
+        const result: TSFunctionType = new TSFunctionType(global.generatedEs2panda._CreateTSFunctionType(global.context, passNode(signature)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_FUNCTION_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSFunctionType(original?: TSFunctionType, signature?: FunctionSignature): TSFunctionType {
-        const result: TSFunctionType = new TSFunctionType(global.generatedEs2panda._UpdateTSFunctionType(global.context, passNode(original), passNode(signature)))
+        const result: TSFunctionType = new TSFunctionType(global.generatedEs2panda._UpdateTSFunctionType(global.context, passNode(original), passNode(signature)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_FUNCTION_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     get typeParams(): TSTypeParameterDeclaration | undefined {
-        return unpackNode(global.generatedEs2panda._TSFunctionTypeTypeParams(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSFunctionTypeTypeParams(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION)
     }
     get params(): readonly Expression[] {
         return unpackNodeArray(global.generatedEs2panda._TSFunctionTypeParamsConst(global.context, this.peer))
@@ -73,5 +71,5 @@ export function isTSFunctionType(node: object | undefined): node is TSFunctionTy
     return node instanceof TSFunctionType
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_FUNCTION_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_FUNCTION_TYPE, (peer: KNativePointer) => new TSFunctionType(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_FUNCTION_TYPE, (peer: KNativePointer) => new TSFunctionType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_FUNCTION_TYPE))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -38,22 +37,21 @@ import { Identifier } from "./Identifier"
 import { Statement } from "./Statement"
 
 export class TSImportEqualsDeclaration extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 126)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSImportEqualsDeclaration(id: Identifier | undefined, moduleReference: Expression | undefined, isExport: boolean): TSImportEqualsDeclaration {
-        const result: TSImportEqualsDeclaration = new TSImportEqualsDeclaration(global.generatedEs2panda._CreateTSImportEqualsDeclaration(global.context, passNode(id), passNode(moduleReference), isExport))
+        const result: TSImportEqualsDeclaration = new TSImportEqualsDeclaration(global.generatedEs2panda._CreateTSImportEqualsDeclaration(global.context, passNode(id), passNode(moduleReference), isExport), Es2pandaAstNodeType.AST_NODE_TYPE_TS_IMPORT_EQUALS_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSImportEqualsDeclaration(original: TSImportEqualsDeclaration | undefined, id: Identifier | undefined, moduleReference: Expression | undefined, isExport: boolean): TSImportEqualsDeclaration {
-        const result: TSImportEqualsDeclaration = new TSImportEqualsDeclaration(global.generatedEs2panda._UpdateTSImportEqualsDeclaration(global.context, passNode(original), passNode(id), passNode(moduleReference), isExport))
+        const result: TSImportEqualsDeclaration = new TSImportEqualsDeclaration(global.generatedEs2panda._UpdateTSImportEqualsDeclaration(global.context, passNode(original), passNode(id), passNode(moduleReference), isExport), Es2pandaAstNodeType.AST_NODE_TYPE_TS_IMPORT_EQUALS_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     get id(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._TSImportEqualsDeclarationIdConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSImportEqualsDeclarationIdConst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)
     }
     get moduleReference(): Expression | undefined {
         return unpackNode(global.generatedEs2panda._TSImportEqualsDeclarationModuleReferenceConst(global.context, this.peer))
@@ -67,5 +65,5 @@ export function isTSImportEqualsDeclaration(node: object | undefined): node is T
     return node instanceof TSImportEqualsDeclaration
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_IMPORT_EQUALS_DECLARATION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_IMPORT_EQUALS_DECLARATION, (peer: KNativePointer) => new TSImportEqualsDeclaration(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_IMPORT_EQUALS_DECLARATION, (peer: KNativePointer) => new TSImportEqualsDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_IMPORT_EQUALS_DECLARATION))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -38,17 +37,16 @@ import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation"
 import { TypeNode } from "./TypeNode"
 
 export class TSImportType extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 114)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSImportType(param: Expression | undefined, typeParams: TSTypeParameterInstantiation | undefined, qualifier: Expression | undefined, isTypeof: boolean): TSImportType {
-        const result: TSImportType = new TSImportType(global.generatedEs2panda._CreateTSImportType(global.context, passNode(param), passNode(typeParams), passNode(qualifier), isTypeof))
+        const result: TSImportType = new TSImportType(global.generatedEs2panda._CreateTSImportType(global.context, passNode(param), passNode(typeParams), passNode(qualifier), isTypeof), Es2pandaAstNodeType.AST_NODE_TYPE_TS_IMPORT_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSImportType(original: TSImportType | undefined, param: Expression | undefined, typeParams: TSTypeParameterInstantiation | undefined, qualifier: Expression | undefined, isTypeof: boolean): TSImportType {
-        const result: TSImportType = new TSImportType(global.generatedEs2panda._UpdateTSImportType(global.context, passNode(original), passNode(param), passNode(typeParams), passNode(qualifier), isTypeof))
+        const result: TSImportType = new TSImportType(global.generatedEs2panda._UpdateTSImportType(global.context, passNode(original), passNode(param), passNode(typeParams), passNode(qualifier), isTypeof), Es2pandaAstNodeType.AST_NODE_TYPE_TS_IMPORT_TYPE)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,7 +54,7 @@ export class TSImportType extends TypeNode {
         return unpackNode(global.generatedEs2panda._TSImportTypeParamConst(global.context, this.peer))
     }
     get typeParams(): TSTypeParameterInstantiation | undefined {
-        return unpackNode(global.generatedEs2panda._TSImportTypeTypeParamsConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSImportTypeTypeParamsConst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION)
     }
     get qualifier(): Expression | undefined {
         return unpackNode(global.generatedEs2panda._TSImportTypeQualifierConst(global.context, this.peer))
@@ -70,5 +68,5 @@ export function isTSImportType(node: object | undefined): node is TSImportType {
     return node instanceof TSImportType
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_IMPORT_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_IMPORT_TYPE, (peer: KNativePointer) => new TSImportType(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_IMPORT_TYPE, (peer: KNativePointer) => new TSImportType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_IMPORT_TYPE))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -39,17 +38,16 @@ import { TypeNode } from "./TypeNode"
 import { TypedAstNode } from "./TypedAstNode"
 
 export class TSIndexSignature extends TypedAstNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 138)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSIndexSignature(param: Expression | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: boolean): TSIndexSignature {
-        const result: TSIndexSignature = new TSIndexSignature(global.generatedEs2panda._CreateTSIndexSignature(global.context, passNode(param), passNode(typeAnnotation), readonly_arg))
+        const result: TSIndexSignature = new TSIndexSignature(global.generatedEs2panda._CreateTSIndexSignature(global.context, passNode(param), passNode(typeAnnotation), readonly_arg), Es2pandaAstNodeType.AST_NODE_TYPE_TS_INDEX_SIGNATURE)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSIndexSignature(original: TSIndexSignature | undefined, param: Expression | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: boolean): TSIndexSignature {
-        const result: TSIndexSignature = new TSIndexSignature(global.generatedEs2panda._UpdateTSIndexSignature(global.context, passNode(original), passNode(param), passNode(typeAnnotation), readonly_arg))
+        const result: TSIndexSignature = new TSIndexSignature(global.generatedEs2panda._UpdateTSIndexSignature(global.context, passNode(original), passNode(param), passNode(typeAnnotation), readonly_arg), Es2pandaAstNodeType.AST_NODE_TYPE_TS_INDEX_SIGNATURE)
         result.setChildrenParentPtr()
         return result
     }
@@ -71,5 +69,5 @@ export function isTSIndexSignature(node: object | undefined): node is TSIndexSig
     return node instanceof TSIndexSignature
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INDEX_SIGNATURE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INDEX_SIGNATURE, (peer: KNativePointer) => new TSIndexSignature(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INDEX_SIGNATURE, (peer: KNativePointer) => new TSIndexSignature(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_INDEX_SIGNATURE))
 }

package/build/libarkts-copy/src/generated/peers/TSIndexedAccessType.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 TSIndexedAccessType extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 132)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSIndexedAccessType(objectType?: TypeNode, indexType?: TypeNode): TSIndexedAccessType {
-        const result: TSIndexedAccessType = new TSIndexedAccessType(global.generatedEs2panda._CreateTSIndexedAccessType(global.context, passNode(objectType), passNode(indexType)))
+        const result: TSIndexedAccessType = new TSIndexedAccessType(global.generatedEs2panda._CreateTSIndexedAccessType(global.context, passNode(objectType), passNode(indexType)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_INDEXED_ACCESS_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSIndexedAccessType(original?: TSIndexedAccessType, objectType?: TypeNode, indexType?: TypeNode): TSIndexedAccessType {
-        const result: TSIndexedAccessType = new TSIndexedAccessType(global.generatedEs2panda._UpdateTSIndexedAccessType(global.context, passNode(original), passNode(objectType), passNode(indexType)))
+        const result: TSIndexedAccessType = new TSIndexedAccessType(global.generatedEs2panda._UpdateTSIndexedAccessType(global.context, passNode(original), passNode(objectType), passNode(indexType)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_INDEXED_ACCESS_TYPE)
         result.setChildrenParentPtr()
         return result
     }
@@ -62,5 +60,5 @@ export function isTSIndexedAccessType(node: object | undefined): node is TSIndex
     return node instanceof TSIndexedAccessType
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INDEXED_ACCESS_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INDEXED_ACCESS_TYPE, (peer: KNativePointer) => new TSIndexedAccessType(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INDEXED_ACCESS_TYPE, (peer: KNativePointer) => new TSIndexedAccessType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_INDEXED_ACCESS_TYPE))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,22 +36,21 @@ import { TSTypeParameter } from "./TSTypeParameter"
 import { TypeNode } from "./TypeNode"
 
 export class TSInferType extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 112)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createTSInferType(typeParam?: TSTypeParameter): TSInferType {
-        const result: TSInferType = new TSInferType(global.generatedEs2panda._CreateTSInferType(global.context, passNode(typeParam)))
+        const result: TSInferType = new TSInferType(global.generatedEs2panda._CreateTSInferType(global.context, passNode(typeParam)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_INFER_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static updateTSInferType(original?: TSInferType, typeParam?: TSTypeParameter): TSInferType {
-        const result: TSInferType = new TSInferType(global.generatedEs2panda._UpdateTSInferType(global.context, passNode(original), passNode(typeParam)))
+        const result: TSInferType = new TSInferType(global.generatedEs2panda._UpdateTSInferType(global.context, passNode(original), passNode(typeParam)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_INFER_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     get typeParam(): TSTypeParameter | undefined {
-        return unpackNode(global.generatedEs2panda._TSInferTypeTypeParamConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSInferTypeTypeParamConst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER)
     }
     protected readonly brandTSInferType: undefined
 }
@@ -60,5 +58,5 @@ export function isTSInferType(node: object | undefined): node is TSInferType {
     return node instanceof TSInferType
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INFER_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INFER_TYPE, (peer: KNativePointer) => new TSInferType(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INFER_TYPE, (peer: KNativePointer) => new TSInferType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_INFER_TYPE))
 }