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

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -38,25 +37,24 @@ import { Statement } from "./Statement"
 import { StringLiteral } from "./StringLiteral"
 
 export class ExportAllDeclaration extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 26)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createExportAllDeclaration(source?: StringLiteral, exported?: Identifier): ExportAllDeclaration {
-        const result: ExportAllDeclaration = new ExportAllDeclaration(global.generatedEs2panda._CreateExportAllDeclaration(global.context, passNode(source), passNode(exported)))
+        const result: ExportAllDeclaration = new ExportAllDeclaration(global.generatedEs2panda._CreateExportAllDeclaration(global.context, passNode(source), passNode(exported)), Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_ALL_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     static updateExportAllDeclaration(original?: ExportAllDeclaration, source?: StringLiteral, exported?: Identifier): ExportAllDeclaration {
-        const result: ExportAllDeclaration = new ExportAllDeclaration(global.generatedEs2panda._UpdateExportAllDeclaration(global.context, passNode(original), passNode(source), passNode(exported)))
+        const result: ExportAllDeclaration = new ExportAllDeclaration(global.generatedEs2panda._UpdateExportAllDeclaration(global.context, passNode(original), passNode(source), passNode(exported)), Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_ALL_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     get source(): StringLiteral | undefined {
-        return unpackNode(global.generatedEs2panda._ExportAllDeclarationSourceConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ExportAllDeclarationSourceConst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL)
     }
     get exported(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._ExportAllDeclarationExportedConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ExportAllDeclarationExportedConst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)
     }
     protected readonly brandExportAllDeclaration: undefined
 }
@@ -64,5 +62,5 @@ export function isExportAllDeclaration(node: object | undefined): node is Export
     return node instanceof ExportAllDeclaration
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_ALL_DECLARATION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_ALL_DECLARATION, (peer: KNativePointer) => new ExportAllDeclaration(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_ALL_DECLARATION, (peer: KNativePointer) => new ExportAllDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_ALL_DECLARATION))
 }

package/build/libarkts-copy/src/generated/peers/ExportDefaultDeclaration.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 ExportDefaultDeclaration extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 27)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createExportDefaultDeclaration(decl: AstNode | undefined, exportEquals: boolean): ExportDefaultDeclaration {
-        const result: ExportDefaultDeclaration = new ExportDefaultDeclaration(global.generatedEs2panda._CreateExportDefaultDeclaration(global.context, passNode(decl), exportEquals))
+        const result: ExportDefaultDeclaration = new ExportDefaultDeclaration(global.generatedEs2panda._CreateExportDefaultDeclaration(global.context, passNode(decl), exportEquals), Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_DEFAULT_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     static updateExportDefaultDeclaration(original: ExportDefaultDeclaration | undefined, decl: AstNode | undefined, exportEquals: boolean): ExportDefaultDeclaration {
-        const result: ExportDefaultDeclaration = new ExportDefaultDeclaration(global.generatedEs2panda._UpdateExportDefaultDeclaration(global.context, passNode(original), passNode(decl), exportEquals))
+        const result: ExportDefaultDeclaration = new ExportDefaultDeclaration(global.generatedEs2panda._UpdateExportDefaultDeclaration(global.context, passNode(original), passNode(decl), exportEquals), Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_DEFAULT_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
@@ -62,5 +60,5 @@ export function isExportDefaultDeclaration(node: object | undefined): node is Ex
     return node instanceof ExportDefaultDeclaration
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_DEFAULT_DECLARATION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_DEFAULT_DECLARATION, (peer: KNativePointer) => new ExportDefaultDeclaration(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_DEFAULT_DECLARATION, (peer: KNativePointer) => new ExportDefaultDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_DEFAULT_DECLARATION))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -38,37 +37,36 @@ import { Statement } from "./Statement"
 import { StringLiteral } from "./StringLiteral"
 
 export class ExportNamedDeclaration extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 28)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createExportNamedDeclaration(source: StringLiteral | undefined, specifiers: readonly ExportSpecifier[]): ExportNamedDeclaration {
-        const result: ExportNamedDeclaration = new ExportNamedDeclaration(global.generatedEs2panda._CreateExportNamedDeclaration(global.context, passNode(source), passNodeArray(specifiers), specifiers.length))
+        const result: ExportNamedDeclaration = new ExportNamedDeclaration(global.generatedEs2panda._CreateExportNamedDeclaration(global.context, passNode(source), passNodeArray(specifiers), specifiers.length), Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_NAMED_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     static updateExportNamedDeclaration(original: ExportNamedDeclaration | undefined, source: StringLiteral | undefined, specifiers: readonly ExportSpecifier[]): ExportNamedDeclaration {
-        const result: ExportNamedDeclaration = new ExportNamedDeclaration(global.generatedEs2panda._UpdateExportNamedDeclaration(global.context, passNode(original), passNode(source), passNodeArray(specifiers), specifiers.length))
+        const result: ExportNamedDeclaration = new ExportNamedDeclaration(global.generatedEs2panda._UpdateExportNamedDeclaration(global.context, passNode(original), passNode(source), passNodeArray(specifiers), specifiers.length), Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_NAMED_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     static create1ExportNamedDeclaration(decl: AstNode | undefined, specifiers: readonly ExportSpecifier[]): ExportNamedDeclaration {
-        const result: ExportNamedDeclaration = new ExportNamedDeclaration(global.generatedEs2panda._CreateExportNamedDeclaration1(global.context, passNode(decl), passNodeArray(specifiers), specifiers.length))
+        const result: ExportNamedDeclaration = new ExportNamedDeclaration(global.generatedEs2panda._CreateExportNamedDeclaration1(global.context, passNode(decl), passNodeArray(specifiers), specifiers.length), Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_NAMED_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     static update1ExportNamedDeclaration(original: ExportNamedDeclaration | undefined, decl: AstNode | undefined, specifiers: readonly ExportSpecifier[]): ExportNamedDeclaration {
-        const result: ExportNamedDeclaration = new ExportNamedDeclaration(global.generatedEs2panda._UpdateExportNamedDeclaration1(global.context, passNode(original), passNode(decl), passNodeArray(specifiers), specifiers.length))
+        const result: ExportNamedDeclaration = new ExportNamedDeclaration(global.generatedEs2panda._UpdateExportNamedDeclaration1(global.context, passNode(original), passNode(decl), passNodeArray(specifiers), specifiers.length), Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_NAMED_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     static create2ExportNamedDeclaration(decl?: AstNode): ExportNamedDeclaration {
-        const result: ExportNamedDeclaration = new ExportNamedDeclaration(global.generatedEs2panda._CreateExportNamedDeclaration2(global.context, passNode(decl)))
+        const result: ExportNamedDeclaration = new ExportNamedDeclaration(global.generatedEs2panda._CreateExportNamedDeclaration2(global.context, passNode(decl)), Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_NAMED_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     static update2ExportNamedDeclaration(original?: ExportNamedDeclaration, decl?: AstNode): ExportNamedDeclaration {
-        const result: ExportNamedDeclaration = new ExportNamedDeclaration(global.generatedEs2panda._UpdateExportNamedDeclaration2(global.context, passNode(original), passNode(decl)))
+        const result: ExportNamedDeclaration = new ExportNamedDeclaration(global.generatedEs2panda._UpdateExportNamedDeclaration2(global.context, passNode(original), passNode(decl)), Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_NAMED_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
@@ -76,10 +74,10 @@ export class ExportNamedDeclaration extends Statement {
         return unpackNode(global.generatedEs2panda._ExportNamedDeclarationDeclConst(global.context, this.peer))
     }
     get source(): StringLiteral | undefined {
-        return unpackNode(global.generatedEs2panda._ExportNamedDeclarationSourceConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ExportNamedDeclarationSourceConst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL)
     }
     get specifiers(): readonly ExportSpecifier[] {
-        return unpackNodeArray(global.generatedEs2panda._ExportNamedDeclarationSpecifiersConst(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._ExportNamedDeclarationSpecifiersConst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_SPECIFIER)
     }
     /** @deprecated */
     replaceSpecifiers(specifiers: readonly ExportSpecifier[]): this {
@@ -92,5 +90,5 @@ export function isExportNamedDeclaration(node: object | undefined): node is Expo
     return node instanceof ExportNamedDeclaration
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_NAMED_DECLARATION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_NAMED_DECLARATION, (peer: KNativePointer) => new ExportNamedDeclaration(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_NAMED_DECLARATION, (peer: KNativePointer) => new ExportNamedDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_NAMED_DECLARATION))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -38,25 +37,24 @@ import { Identifier } from "./Identifier"
 import { Statement } from "./Statement"
 
 export class ExportSpecifier extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 29)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createExportSpecifier(local?: Identifier, exported?: Identifier): ExportSpecifier {
-        const result: ExportSpecifier = new ExportSpecifier(global.generatedEs2panda._CreateExportSpecifier(global.context, passNode(local), passNode(exported)))
+        const result: ExportSpecifier = new ExportSpecifier(global.generatedEs2panda._CreateExportSpecifier(global.context, passNode(local), passNode(exported)), Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_SPECIFIER)
         result.setChildrenParentPtr()
         return result
     }
     static updateExportSpecifier(original?: ExportSpecifier, local?: Identifier, exported?: Identifier): ExportSpecifier {
-        const result: ExportSpecifier = new ExportSpecifier(global.generatedEs2panda._UpdateExportSpecifier(global.context, passNode(original), passNode(local), passNode(exported)))
+        const result: ExportSpecifier = new ExportSpecifier(global.generatedEs2panda._UpdateExportSpecifier(global.context, passNode(original), passNode(local), passNode(exported)), Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_SPECIFIER)
         result.setChildrenParentPtr()
         return result
     }
     get local(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._ExportSpecifierLocalConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ExportSpecifierLocalConst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)
     }
     get exported(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._ExportSpecifierExportedConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ExportSpecifierExportedConst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)
     }
     /** @deprecated */
     setDefault(): this {
@@ -80,5 +78,5 @@ export function isExportSpecifier(node: object | undefined): node is ExportSpeci
     return node instanceof ExportSpecifier
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_SPECIFIER)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_SPECIFIER, (peer: KNativePointer) => new ExportSpecifier(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_SPECIFIER, (peer: KNativePointer) => new ExportSpecifier(peer, Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_SPECIFIER))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -33,13 +32,16 @@ import {
 } from "../../reexport-for-generated"
 
 import { AnnotatedExpression } from "./AnnotatedExpression"
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Literal } from "./Literal"
 import { TypeNode } from "./TypeNode"
 import { TypedAstNode } from "./TypedAstNode"
+import { extension_ExpressionGetPreferredTypePointer } from "./../../reexport-for-generated"
+import { extension_ExpressionSetPreferredTypePointer } from "./../../reexport-for-generated"
 
 export class Expression extends TypedAstNode {
-    constructor(pointer: KNativePointer) {
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     get isGrouped(): boolean {
         return global.generatedEs2panda._ExpressionIsGroupedConst(global.context, this.peer)
@@ -73,6 +75,8 @@ export class Expression extends TypedAstNode {
     get toString(): string {
         return unpackString(global.generatedEs2panda._ExpressionToStringConst(global.context, this.peer))
     }
+    getPreferredTypePointer = extension_ExpressionGetPreferredTypePointer
+    setPreferredTypePointer = extension_ExpressionSetPreferredTypePointer
     protected readonly brandExpression: undefined
 }
 export function isExpression(node: object | undefined): node is Expression {

package/build/libarkts-copy/src/generated/peers/ExpressionStatement.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 ExpressionStatement extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 30)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createExpressionStatement(expr?: Expression): ExpressionStatement {
-        const result: ExpressionStatement = new ExpressionStatement(global.generatedEs2panda._CreateExpressionStatement(global.context, passNode(expr)))
+        const result: ExpressionStatement = new ExpressionStatement(global.generatedEs2panda._CreateExpressionStatement(global.context, passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_EXPRESSION_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static updateExpressionStatement(original?: ExpressionStatement, expr?: Expression): ExpressionStatement {
-        const result: ExpressionStatement = new ExpressionStatement(global.generatedEs2panda._UpdateExpressionStatement(global.context, passNode(original), passNode(expr)))
+        const result: ExpressionStatement = new ExpressionStatement(global.generatedEs2panda._UpdateExpressionStatement(global.context, passNode(original), passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_EXPRESSION_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
@@ -65,5 +63,5 @@ export function isExpressionStatement(node: object | undefined): node is Express
     return node instanceof ExpressionStatement
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_EXPRESSION_STATEMENT)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_EXPRESSION_STATEMENT, (peer: KNativePointer) => new ExpressionStatement(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_EXPRESSION_STATEMENT, (peer: KNativePointer) => new ExpressionStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_EXPRESSION_STATEMENT))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -38,17 +37,16 @@ import { LoopStatement } from "./LoopStatement"
 import { Statement } from "./Statement"
 
 export class ForInStatement extends LoopStatement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 31)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createForInStatement(left?: AstNode, right?: Expression, body?: Statement): ForInStatement {
-        const result: ForInStatement = new ForInStatement(global.generatedEs2panda._CreateForInStatement(global.context, passNode(left), passNode(right), passNode(body)))
+        const result: ForInStatement = new ForInStatement(global.generatedEs2panda._CreateForInStatement(global.context, passNode(left), passNode(right), passNode(body)), Es2pandaAstNodeType.AST_NODE_TYPE_FOR_IN_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static updateForInStatement(original?: ForInStatement, left?: AstNode, right?: Expression, body?: Statement): ForInStatement {
-        const result: ForInStatement = new ForInStatement(global.generatedEs2panda._UpdateForInStatement(global.context, passNode(original), passNode(left), passNode(right), passNode(body)))
+        const result: ForInStatement = new ForInStatement(global.generatedEs2panda._UpdateForInStatement(global.context, passNode(original), passNode(left), passNode(right), passNode(body)), Es2pandaAstNodeType.AST_NODE_TYPE_FOR_IN_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
@@ -67,5 +65,5 @@ export function isForInStatement(node: object | undefined): node is ForInStateme
     return node instanceof ForInStatement
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_FOR_IN_STATEMENT)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_FOR_IN_STATEMENT, (peer: KNativePointer) => new ForInStatement(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_FOR_IN_STATEMENT, (peer: KNativePointer) => new ForInStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_FOR_IN_STATEMENT))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -38,17 +37,16 @@ import { LoopStatement } from "./LoopStatement"
 import { Statement } from "./Statement"
 
 export class ForOfStatement extends LoopStatement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 32)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createForOfStatement(left: AstNode | undefined, right: Expression | undefined, body: Statement | undefined, isAwait: boolean): ForOfStatement {
-        const result: ForOfStatement = new ForOfStatement(global.generatedEs2panda._CreateForOfStatement(global.context, passNode(left), passNode(right), passNode(body), isAwait))
+        const result: ForOfStatement = new ForOfStatement(global.generatedEs2panda._CreateForOfStatement(global.context, passNode(left), passNode(right), passNode(body), isAwait), Es2pandaAstNodeType.AST_NODE_TYPE_FOR_OF_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static updateForOfStatement(original: ForOfStatement | undefined, left: AstNode | undefined, right: Expression | undefined, body: Statement | undefined, isAwait: boolean): ForOfStatement {
-        const result: ForOfStatement = new ForOfStatement(global.generatedEs2panda._UpdateForOfStatement(global.context, passNode(original), passNode(left), passNode(right), passNode(body), isAwait))
+        const result: ForOfStatement = new ForOfStatement(global.generatedEs2panda._UpdateForOfStatement(global.context, passNode(original), passNode(left), passNode(right), passNode(body), isAwait), Es2pandaAstNodeType.AST_NODE_TYPE_FOR_OF_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
@@ -70,5 +68,5 @@ export function isForOfStatement(node: object | undefined): node is ForOfStateme
     return node instanceof ForOfStatement
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_FOR_OF_STATEMENT)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_FOR_OF_STATEMENT, (peer: KNativePointer) => new ForOfStatement(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_FOR_OF_STATEMENT, (peer: KNativePointer) => new ForOfStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_FOR_OF_STATEMENT))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -38,12 +37,11 @@ import { LoopStatement } from "./LoopStatement"
 import { Statement } from "./Statement"
 
 export class ForUpdateStatement extends LoopStatement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 33)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createForUpdateStatement(init?: AstNode, test?: Expression, update?: Expression, body?: Statement): ForUpdateStatement {
-        const result: ForUpdateStatement = new ForUpdateStatement(global.generatedEs2panda._CreateForUpdateStatement(global.context, passNode(init), passNode(test), passNode(update), passNode(body)))
+        const result: ForUpdateStatement = new ForUpdateStatement(global.generatedEs2panda._CreateForUpdateStatement(global.context, passNode(init), passNode(test), passNode(update), passNode(body)), Es2pandaAstNodeType.AST_NODE_TYPE_FOR_UPDATE_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
@@ -65,5 +63,5 @@ export function isForUpdateStatement(node: object | undefined): node is ForUpdat
     return node instanceof ForUpdateStatement
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_FOR_UPDATE_STATEMENT)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_FOR_UPDATE_STATEMENT, (peer: KNativePointer) => new ForUpdateStatement(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_FOR_UPDATE_STATEMENT, (peer: KNativePointer) => new ForUpdateStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_FOR_UPDATE_STATEMENT))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -33,43 +32,42 @@ import {
 } from "../../reexport-for-generated"
 
 import { AnnotationUsage } from "./AnnotationUsage"
-import { Decorator } from "./Decorator"
 import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { ScriptFunction } from "./ScriptFunction"
+import { SrcDumper } from "./SrcDumper"
 import { Statement } from "./Statement"
 
 export class FunctionDeclaration extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 34)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createFunctionDeclaration(func: ScriptFunction | undefined, annotations: readonly AnnotationUsage[], isAnonymous: boolean): FunctionDeclaration {
-        const result: FunctionDeclaration = new FunctionDeclaration(global.generatedEs2panda._CreateFunctionDeclaration(global.context, passNode(func), passNodeArray(annotations), annotations.length, isAnonymous))
+        const result: FunctionDeclaration = new FunctionDeclaration(global.generatedEs2panda._CreateFunctionDeclaration(global.context, passNode(func), passNodeArray(annotations), annotations.length, isAnonymous), Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     static updateFunctionDeclaration(original: FunctionDeclaration | undefined, func: ScriptFunction | undefined, annotations: readonly AnnotationUsage[], isAnonymous: boolean): FunctionDeclaration {
-        const result: FunctionDeclaration = new FunctionDeclaration(global.generatedEs2panda._UpdateFunctionDeclaration(global.context, passNode(original), passNode(func), passNodeArray(annotations), annotations.length, isAnonymous))
+        const result: FunctionDeclaration = new FunctionDeclaration(global.generatedEs2panda._UpdateFunctionDeclaration(global.context, passNode(original), passNode(func), passNodeArray(annotations), annotations.length, isAnonymous), Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     static update1FunctionDeclaration(original: FunctionDeclaration | undefined, func: ScriptFunction | undefined, isAnonymous: boolean): FunctionDeclaration {
-        const result: FunctionDeclaration = new FunctionDeclaration(global.generatedEs2panda._UpdateFunctionDeclaration1(global.context, passNode(original), passNode(func), isAnonymous))
+        const result: FunctionDeclaration = new FunctionDeclaration(global.generatedEs2panda._UpdateFunctionDeclaration1(global.context, passNode(original), passNode(func), isAnonymous), Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     get function(): ScriptFunction | undefined {
-        return unpackNode(global.generatedEs2panda._FunctionDeclarationFunction(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._FunctionDeclarationFunction(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION)
     }
     get isAnonymous(): boolean {
         return global.generatedEs2panda._FunctionDeclarationIsAnonymousConst(global.context, this.peer)
     }
-    get decorators(): readonly Decorator[] {
-        return unpackNodeArray(global.generatedEs2panda._FunctionDeclarationDecoratorsConst(global.context, this.peer))
+    get hasAnnotations(): boolean {
+        return global.generatedEs2panda._FunctionDeclarationHasAnnotationsConst(global.context, this.peer)
     }
     /** @deprecated */
-    emplaceAnnotations(source?: AnnotationUsage): this {
-        global.generatedEs2panda._FunctionDeclarationEmplaceAnnotations(global.context, this.peer, passNode(source))
+    emplaceAnnotation(source?: AnnotationUsage): this {
+        global.generatedEs2panda._FunctionDeclarationEmplaceAnnotation(global.context, this.peer, passNode(source))
         return this
     }
     /** @deprecated */
@@ -78,15 +76,15 @@ export class FunctionDeclaration extends Statement {
         return this
     }
     /** @deprecated */
-    setValueAnnotations(source: AnnotationUsage | undefined, index: number): this {
-        global.generatedEs2panda._FunctionDeclarationSetValueAnnotations(global.context, this.peer, passNode(source), index)
+    dumpAnnotations(dumper?: SrcDumper): this {
+        global.generatedEs2panda._FunctionDeclarationDumpAnnotationsConst(global.context, this.peer, passNode(dumper))
         return this
     }
     get annotationsForUpdate(): readonly AnnotationUsage[] {
-        return unpackNodeArray(global.generatedEs2panda._FunctionDeclarationAnnotationsForUpdate(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._FunctionDeclarationAnnotationsForUpdate(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE)
     }
     get annotations(): readonly AnnotationUsage[] {
-        return unpackNodeArray(global.generatedEs2panda._FunctionDeclarationAnnotations(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._FunctionDeclarationAnnotations(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE)
     }
     /** @deprecated */
     setAnnotations(annotationList: readonly AnnotationUsage[]): this {
@@ -98,16 +96,11 @@ export class FunctionDeclaration extends Statement {
         global.generatedEs2panda._FunctionDeclarationSetAnnotations1(global.context, this.peer, passNodeArray(annotationList), annotationList.length)
         return this
     }
-    /** @deprecated */
-    addAnnotations(annotations?: AnnotationUsage): this {
-        global.generatedEs2panda._FunctionDeclarationAddAnnotations(global.context, this.peer, passNode(annotations))
-        return this
-    }
     protected readonly brandFunctionDeclaration: undefined
 }
 export function isFunctionDeclaration(node: object | undefined): node is FunctionDeclaration {
     return node instanceof FunctionDeclaration
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_DECLARATION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_DECLARATION, (peer: KNativePointer) => new FunctionDeclaration(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_DECLARATION, (peer: KNativePointer) => new FunctionDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_DECLARATION))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -38,33 +37,32 @@ import { Identifier } from "./Identifier"
 import { ScriptFunction } from "./ScriptFunction"
 
 export class FunctionExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 35)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static create1FunctionExpression(namedExpr?: Identifier, func?: ScriptFunction): FunctionExpression {
-        const result: FunctionExpression = new FunctionExpression(global.generatedEs2panda._CreateFunctionExpression1(global.context, passNode(namedExpr), passNode(func)))
+        const result: FunctionExpression = new FunctionExpression(global.generatedEs2panda._CreateFunctionExpression1(global.context, passNode(namedExpr), passNode(func)), Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateFunctionExpression(original?: FunctionExpression, func?: ScriptFunction): FunctionExpression {
-        const result: FunctionExpression = new FunctionExpression(global.generatedEs2panda._UpdateFunctionExpression(global.context, passNode(original), passNode(func)))
+        const result: FunctionExpression = new FunctionExpression(global.generatedEs2panda._UpdateFunctionExpression(global.context, passNode(original), passNode(func)), Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static update1FunctionExpression(original?: FunctionExpression, namedExpr?: Identifier, func?: ScriptFunction): FunctionExpression {
-        const result: FunctionExpression = new FunctionExpression(global.generatedEs2panda._UpdateFunctionExpression1(global.context, passNode(original), passNode(namedExpr), passNode(func)))
+        const result: FunctionExpression = new FunctionExpression(global.generatedEs2panda._UpdateFunctionExpression1(global.context, passNode(original), passNode(namedExpr), passNode(func)), Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     get function(): ScriptFunction | undefined {
-        return unpackNode(global.generatedEs2panda._FunctionExpressionFunction(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._FunctionExpressionFunction(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION)
     }
     get isAnonymous(): boolean {
         return global.generatedEs2panda._FunctionExpressionIsAnonymousConst(global.context, this.peer)
     }
     get id(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._FunctionExpressionId(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._FunctionExpressionId(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)
     }
     protected readonly brandFunctionExpression: undefined
 }
@@ -72,5 +70,5 @@ export function isFunctionExpression(node: object | undefined): node is Function
     return node instanceof FunctionExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_EXPRESSION, (peer: KNativePointer) => new FunctionExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_EXPRESSION, (peer: KNativePointer) => new FunctionExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_EXPRESSION))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -32,6 +31,7 @@ import {
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration"
 import { TypeNode } from "./TypeNode"
@@ -47,7 +47,7 @@ export class FunctionSignature extends ArktsObject {
         return unpackNodeArray(global.generatedEs2panda._FunctionSignatureParams(global.context, this.peer))
     }
     get typeParams(): TSTypeParameterDeclaration | undefined {
-        return unpackNode(global.generatedEs2panda._FunctionSignatureTypeParams(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._FunctionSignatureTypeParams(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION)
     }
     get returnType(): TypeNode | undefined {
         return unpackNode(global.generatedEs2panda._FunctionSignatureReturnType(global.context, this.peer))
@@ -65,3 +65,6 @@ export class FunctionSignature extends ArktsObject {
     }
     protected readonly brandFunctionSignature: undefined
 }
+export function isFunctionSignature(node: object | undefined): node is FunctionSignature {
+    return node instanceof FunctionSignature
+}

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,