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

package/build/libarkts-copy/src/generated/factory.ts

@@ -1052,11 +1052,11 @@ export const factory = {
         return updateNodeByNode(TSAnyKeyword.createTSAnyKeyword(), original)
     }
     ,
-    createClassDeclaration(definition?: ClassDefinition, modifierFlags?: Es2pandaModifierFlags): ClassDeclaration {
+    createClassDeclaration(definition: ClassDefinition, modifierFlags?: Es2pandaModifierFlags): ClassDeclaration {
         return ClassDeclaration.createClassDeclaration(definition, modifierFlags)
     }
     ,
-    updateClassDeclaration(original: ClassDeclaration, definition?: ClassDefinition, modifierFlags?: Es2pandaModifierFlags): ClassDeclaration {
+    updateClassDeclaration(original: ClassDeclaration, definition: ClassDefinition, modifierFlags?: Es2pandaModifierFlags): ClassDeclaration {
         if (isSameNativeObject(definition, original.definition) && isSameNativeObject(modifierFlags, original.modifierFlags))
             return original
         return updateNodeByNode(ClassDeclaration.createClassDeclaration(definition, modifierFlags), original)

package/build/libarkts-copy/src/generated/index.ts

@@ -20,10 +20,13 @@
 
 export * from "./peers/SourcePosition"
 export * from "./peers/SourceRange"
+export * from "./peers/SrcDumper"
+export * from "./peers/AstDumper"
 export * from "./peers/LabelPair"
 export * from "./peers/ScriptFunctionData"
 export * from "./peers/ImportSource"
 export * from "./peers/SignatureInfo"
+export * from "./peers/ValidationInfo"
 export * from "./peers/IndexInfo"
 export * from "./peers/ObjectDescriptor"
 export * from "./peers/ScopeFindResult"
@@ -215,7 +218,5 @@ export * from "./peers/NewExpression"
 export * from "./peers/TSParameterProperty"
 export * from "./peers/ETSWildcardType"
 export * from "./peers/TSThisType"
-export * from "./peers/InterfaceDecl"
-export * from "./peers/FunctionDecl"
 export * from "./peers/Program"
 export * from "./peers/ArkTsConfig"

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

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

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

@@ -32,12 +32,13 @@ import {
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { TypeNode } from "./TypeNode"
 
 export class AnnotatedExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     get typeAnnotation(): TypeNode | undefined {
         return unpackNode(global.generatedEs2panda._AnnotatedExpressionTypeAnnotationConst(global.context, this.peer))

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

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

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

@@ -39,22 +39,21 @@ import { Identifier } from "./Identifier"
 import { Statement } from "./Statement"
 
 export class AnnotationDeclaration extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 1)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static create1AnnotationDeclaration(expr: Expression | undefined, properties: readonly AstNode[]): AnnotationDeclaration {
-        const result: AnnotationDeclaration = new AnnotationDeclaration(global.generatedEs2panda._CreateAnnotationDeclaration1(global.context, passNode(expr), passNodeArray(properties), properties.length))
+        const result: AnnotationDeclaration = new AnnotationDeclaration(global.generatedEs2panda._CreateAnnotationDeclaration1(global.context, passNode(expr), passNodeArray(properties), properties.length), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     static updateAnnotationDeclaration(original?: AnnotationDeclaration, expr?: Expression): AnnotationDeclaration {
-        const result: AnnotationDeclaration = new AnnotationDeclaration(global.generatedEs2panda._UpdateAnnotationDeclaration(global.context, passNode(original), passNode(expr)))
+        const result: AnnotationDeclaration = new AnnotationDeclaration(global.generatedEs2panda._UpdateAnnotationDeclaration(global.context, passNode(original), passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     static update1AnnotationDeclaration(original: AnnotationDeclaration | undefined, expr: Expression | undefined, properties: readonly AstNode[]): AnnotationDeclaration {
-        const result: AnnotationDeclaration = new AnnotationDeclaration(global.generatedEs2panda._UpdateAnnotationDeclaration1(global.context, passNode(original), passNode(expr), passNodeArray(properties), properties.length))
+        const result: AnnotationDeclaration = new AnnotationDeclaration(global.generatedEs2panda._UpdateAnnotationDeclaration1(global.context, passNode(original), passNode(expr), passNodeArray(properties), properties.length), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
@@ -164,5 +163,5 @@ export function isAnnotationDeclaration(node: object | undefined): node is Annot
     return node instanceof AnnotationDeclaration
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_DECLARATION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_DECLARATION, (peer: KNativePointer) => new AnnotationDeclaration(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_DECLARATION, (peer: KNativePointer) => new AnnotationDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_DECLARATION))
 }

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

@@ -38,22 +38,21 @@ import { Identifier } from "./Identifier"
 import { Statement } from "./Statement"
 
 export class AnnotationUsage extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 2)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static create1AnnotationUsage(expr: Expression | undefined, properties: readonly AstNode[]): AnnotationUsage {
-        const result: AnnotationUsage = new AnnotationUsage(global.generatedEs2panda._CreateAnnotationUsage1(global.context, passNode(expr), passNodeArray(properties), properties.length))
+        const result: AnnotationUsage = new AnnotationUsage(global.generatedEs2panda._CreateAnnotationUsage1(global.context, passNode(expr), passNodeArray(properties), properties.length), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE)
         result.setChildrenParentPtr()
         return result
     }
     static updateAnnotationUsage(original?: AnnotationUsage, expr?: Expression): AnnotationUsage {
-        const result: AnnotationUsage = new AnnotationUsage(global.generatedEs2panda._UpdateAnnotationUsage(global.context, passNode(original), passNode(expr)))
+        const result: AnnotationUsage = new AnnotationUsage(global.generatedEs2panda._UpdateAnnotationUsage(global.context, passNode(original), passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE)
         result.setChildrenParentPtr()
         return result
     }
     static update1AnnotationUsage(original: AnnotationUsage | undefined, expr: Expression | undefined, properties: readonly AstNode[]): AnnotationUsage {
-        const result: AnnotationUsage = new AnnotationUsage(global.generatedEs2panda._UpdateAnnotationUsage1(global.context, passNode(original), passNode(expr), passNodeArray(properties), properties.length))
+        const result: AnnotationUsage = new AnnotationUsage(global.generatedEs2panda._UpdateAnnotationUsage1(global.context, passNode(original), passNode(expr), passNodeArray(properties), properties.length), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE)
         result.setChildrenParentPtr()
         return result
     }
@@ -82,5 +81,5 @@ export function isAnnotationUsage(node: object | undefined): node is AnnotationU
     return node instanceof AnnotationUsage
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE, (peer: KNativePointer) => new AnnotationUsage(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE, (peer: KNativePointer) => new AnnotationUsage(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE))
 }

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

@@ -32,11 +32,15 @@ import {
     unpackString
 } from "../../reexport-for-generated"
 
+import { ErrorLogger } from "./ErrorLogger"
 
 export class ArkTsConfig extends ArktsObject {
     constructor(pointer: KNativePointer) {
         super(pointer)
     }
+    static createArkTsConfig(configPath: string, de?: ErrorLogger): ArkTsConfig {
+        return new ArkTsConfig(global.generatedEs2panda._CreateArkTsConfig(global.context, configPath, passNode(de)))
+    }
     /** @deprecated */
     resolveAllDependenciesInArkTsConfig(): this {
         global.generatedEs2panda._ArkTsConfigResolveAllDependenciesInArkTsConfig(global.context, this.peer)

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

@@ -40,22 +40,21 @@ import { TypeNode } from "./TypeNode"
 import { ValidationInfo } from "./ValidationInfo"
 
 export class ArrayExpression extends AnnotatedExpression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 159)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static create1ArrayExpression(nodeType: Es2pandaAstNodeType, elements: readonly Expression[], trailingComma: boolean): ArrayExpression {
-        const result: ArrayExpression = new ArrayExpression(global.generatedEs2panda._CreateArrayExpression1(global.context, nodeType, passNodeArray(elements), elements.length, trailingComma))
+        const result: ArrayExpression = new ArrayExpression(global.generatedEs2panda._CreateArrayExpression1(global.context, nodeType, passNodeArray(elements), elements.length, trailingComma), Es2pandaAstNodeType.AST_NODE_TYPE_ARRAY_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateArrayExpression(original: ArrayExpression | undefined, elements: readonly Expression[]): ArrayExpression {
-        const result: ArrayExpression = new ArrayExpression(global.generatedEs2panda._UpdateArrayExpression(global.context, passNode(original), passNodeArray(elements), elements.length))
+        const result: ArrayExpression = new ArrayExpression(global.generatedEs2panda._UpdateArrayExpression(global.context, passNode(original), passNodeArray(elements), elements.length), Es2pandaAstNodeType.AST_NODE_TYPE_ARRAY_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static update1ArrayExpression(original: ArrayExpression | undefined, nodeType: Es2pandaAstNodeType, elements: readonly Expression[], trailingComma: boolean): ArrayExpression {
-        const result: ArrayExpression = new ArrayExpression(global.generatedEs2panda._UpdateArrayExpression1(global.context, passNode(original), nodeType, passNodeArray(elements), elements.length, trailingComma))
+        const result: ArrayExpression = new ArrayExpression(global.generatedEs2panda._UpdateArrayExpression1(global.context, passNode(original), nodeType, passNodeArray(elements), elements.length, trailingComma), Es2pandaAstNodeType.AST_NODE_TYPE_ARRAY_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -111,5 +110,5 @@ export function isArrayExpression(node: object | undefined): node is ArrayExpres
     return node instanceof ArrayExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ARRAY_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ARRAY_EXPRESSION, (peer: KNativePointer) => new ArrayExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ARRAY_EXPRESSION, (peer: KNativePointer) => new ArrayExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ARRAY_EXPRESSION))
 }

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

@@ -39,12 +39,11 @@ import { ScriptFunction } from "./ScriptFunction"
 import { TypeNode } from "./TypeNode"
 
 export class ArrowFunctionExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 0)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createArrowFunctionExpression(func?: ScriptFunction, annotations?: readonly AnnotationUsage[]): ArrowFunctionExpression {
-        const result: ArrowFunctionExpression = new ArrowFunctionExpression(global.generatedEs2panda._CreateArrowFunctionExpression(global.context, passNode(func)))
+        const result: ArrowFunctionExpression = new ArrowFunctionExpression(global.generatedEs2panda._CreateArrowFunctionExpression(global.context, passNode(func)), Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -53,7 +52,7 @@ export class ArrowFunctionExpression extends Expression {
         return result
     }
     static updateArrowFunctionExpression(original?: ArrowFunctionExpression, func?: ScriptFunction, annotations?: readonly AnnotationUsage[]): ArrowFunctionExpression {
-        const result: ArrowFunctionExpression = new ArrowFunctionExpression(global.generatedEs2panda._UpdateArrowFunctionExpression(global.context, passNode(original), passNode(func)))
+        const result: ArrowFunctionExpression = new ArrowFunctionExpression(global.generatedEs2panda._UpdateArrowFunctionExpression(global.context, passNode(original), passNode(func)), Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -62,7 +61,7 @@ export class ArrowFunctionExpression extends Expression {
         return result
     }
     static update1ArrowFunctionExpression(original?: ArrowFunctionExpression, other?: ArrowFunctionExpression, annotations?: readonly AnnotationUsage[]): ArrowFunctionExpression {
-        const result: ArrowFunctionExpression = new ArrowFunctionExpression(global.generatedEs2panda._UpdateArrowFunctionExpression1(global.context, passNode(original), passNode(other)))
+        const result: ArrowFunctionExpression = new ArrowFunctionExpression(global.generatedEs2panda._UpdateArrowFunctionExpression1(global.context, passNode(original), passNode(other)), Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -118,5 +117,5 @@ export function isArrowFunctionExpression(node: object | undefined): node is Arr
     return node instanceof ArrowFunctionExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION, (peer: KNativePointer) => new ArrowFunctionExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION, (peer: KNativePointer) => new ArrowFunctionExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION))
 }

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

@@ -37,17 +37,16 @@ import { Expression } from "./Expression"
 import { Statement } from "./Statement"
 
 export class AssertStatement extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 3)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createAssertStatement(test?: Expression, second?: Expression): AssertStatement {
-        const result: AssertStatement = new AssertStatement(global.generatedEs2panda._CreateAssertStatement(global.context, passNode(test), passNode(second)))
+        const result: AssertStatement = new AssertStatement(global.generatedEs2panda._CreateAssertStatement(global.context, passNode(test), passNode(second)), Es2pandaAstNodeType.AST_NODE_TYPE_ASSERT_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static updateAssertStatement(original?: AssertStatement, test?: Expression, second?: Expression): AssertStatement {
-        const result: AssertStatement = new AssertStatement(global.generatedEs2panda._UpdateAssertStatement(global.context, passNode(original), passNode(test), passNode(second)))
+        const result: AssertStatement = new AssertStatement(global.generatedEs2panda._UpdateAssertStatement(global.context, passNode(original), passNode(test), passNode(second)), Es2pandaAstNodeType.AST_NODE_TYPE_ASSERT_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
@@ -63,5 +62,5 @@ export function isAssertStatement(node: object | undefined): node is AssertState
     return node instanceof AssertStatement
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ASSERT_STATEMENT)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ASSERT_STATEMENT, (peer: KNativePointer) => new AssertStatement(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ASSERT_STATEMENT, (peer: KNativePointer) => new AssertStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ASSERT_STATEMENT))
 }

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

@@ -38,22 +38,21 @@ import { Es2pandaTokenType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 
 export class AssignmentExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 161)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static create1AssignmentExpression(type: Es2pandaAstNodeType, left: Expression | undefined, right: Expression | undefined, assignmentOperator: Es2pandaTokenType): AssignmentExpression {
-        const result: AssignmentExpression = new AssignmentExpression(global.generatedEs2panda._CreateAssignmentExpression1(global.context, type, passNode(left), passNode(right), assignmentOperator))
+        const result: AssignmentExpression = new AssignmentExpression(global.generatedEs2panda._CreateAssignmentExpression1(global.context, type, passNode(left), passNode(right), assignmentOperator), Es2pandaAstNodeType.AST_NODE_TYPE_ASSIGNMENT_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateAssignmentExpression(original: AssignmentExpression | undefined, left: Expression | undefined, right: Expression | undefined, assignmentOperator: Es2pandaTokenType): AssignmentExpression {
-        const result: AssignmentExpression = new AssignmentExpression(global.generatedEs2panda._UpdateAssignmentExpression(global.context, passNode(original), passNode(left), passNode(right), assignmentOperator))
+        const result: AssignmentExpression = new AssignmentExpression(global.generatedEs2panda._UpdateAssignmentExpression(global.context, passNode(original), passNode(left), passNode(right), assignmentOperator), Es2pandaAstNodeType.AST_NODE_TYPE_ASSIGNMENT_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static update1AssignmentExpression(original: AssignmentExpression | undefined, type: Es2pandaAstNodeType, left: Expression | undefined, right: Expression | undefined, assignmentOperator: Es2pandaTokenType): AssignmentExpression {
-        const result: AssignmentExpression = new AssignmentExpression(global.generatedEs2panda._UpdateAssignmentExpression1(global.context, passNode(original), type, passNode(left), passNode(right), assignmentOperator))
+        const result: AssignmentExpression = new AssignmentExpression(global.generatedEs2panda._UpdateAssignmentExpression1(global.context, passNode(original), type, passNode(left), passNode(right), assignmentOperator), Es2pandaAstNodeType.AST_NODE_TYPE_ASSIGNMENT_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -109,5 +108,5 @@ export function isAssignmentExpression(node: object | undefined): node is Assign
     return node instanceof AssignmentExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ASSIGNMENT_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ASSIGNMENT_EXPRESSION, (peer: KNativePointer) => new AssignmentExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ASSIGNMENT_EXPRESSION, (peer: KNativePointer) => new AssignmentExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ASSIGNMENT_EXPRESSION))
 }

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

@@ -45,3 +45,6 @@ export class AstDumper extends ArktsObject {
     }
     protected readonly brandAstDumper: undefined
 }
+export function isAstDumper(node: object | undefined): node is AstDumper {
+    return node instanceof AstDumper
+}

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

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 
 export class AwaitExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 4)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createAwaitExpression(argument?: Expression): AwaitExpression {
-        const result: AwaitExpression = new AwaitExpression(global.generatedEs2panda._CreateAwaitExpression(global.context, passNode(argument)))
+        const result: AwaitExpression = new AwaitExpression(global.generatedEs2panda._CreateAwaitExpression(global.context, passNode(argument)), Es2pandaAstNodeType.AST_NODE_TYPE_AWAIT_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateAwaitExpression(original?: AwaitExpression, argument?: Expression): AwaitExpression {
-        const result: AwaitExpression = new AwaitExpression(global.generatedEs2panda._UpdateAwaitExpression(global.context, passNode(original), passNode(argument)))
+        const result: AwaitExpression = new AwaitExpression(global.generatedEs2panda._UpdateAwaitExpression(global.context, passNode(original), passNode(argument)), Es2pandaAstNodeType.AST_NODE_TYPE_AWAIT_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -59,5 +58,5 @@ export function isAwaitExpression(node: object | undefined): node is AwaitExpres
     return node instanceof AwaitExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_AWAIT_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_AWAIT_EXPRESSION, (peer: KNativePointer) => new AwaitExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_AWAIT_EXPRESSION, (peer: KNativePointer) => new AwaitExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_AWAIT_EXPRESSION))
 }

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

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Literal } from "./Literal"
 
 export class BigIntLiteral extends Literal {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 5)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createBigIntLiteral(src: string): BigIntLiteral {
-        const result: BigIntLiteral = new BigIntLiteral(global.generatedEs2panda._CreateBigIntLiteral(global.context, src))
+        const result: BigIntLiteral = new BigIntLiteral(global.generatedEs2panda._CreateBigIntLiteral(global.context, src), Es2pandaAstNodeType.AST_NODE_TYPE_BIGINT_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
     static updateBigIntLiteral(original: BigIntLiteral | undefined, src: string): BigIntLiteral {
-        const result: BigIntLiteral = new BigIntLiteral(global.generatedEs2panda._UpdateBigIntLiteral(global.context, passNode(original), src))
+        const result: BigIntLiteral = new BigIntLiteral(global.generatedEs2panda._UpdateBigIntLiteral(global.context, passNode(original), src), Es2pandaAstNodeType.AST_NODE_TYPE_BIGINT_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
@@ -59,5 +58,5 @@ export function isBigIntLiteral(node: object | undefined): node is BigIntLiteral
     return node instanceof BigIntLiteral
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_BIGINT_LITERAL)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BIGINT_LITERAL, (peer: KNativePointer) => new BigIntLiteral(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BIGINT_LITERAL, (peer: KNativePointer) => new BigIntLiteral(peer, Es2pandaAstNodeType.AST_NODE_TYPE_BIGINT_LITERAL))
 }

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

@@ -39,17 +39,16 @@ import { Expression } from "./Expression"
 import { VReg } from "./VReg"
 
 export class BinaryExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 6)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createBinaryExpression(left: Expression | undefined, right: Expression | undefined, operatorType: Es2pandaTokenType): BinaryExpression {
-        const result: BinaryExpression = new BinaryExpression(global.generatedEs2panda._CreateBinaryExpression(global.context, passNode(left), passNode(right), operatorType))
+        const result: BinaryExpression = new BinaryExpression(global.generatedEs2panda._CreateBinaryExpression(global.context, passNode(left), passNode(right), operatorType), Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateBinaryExpression(original: BinaryExpression | undefined, left: Expression | undefined, right: Expression | undefined, operatorType: Es2pandaTokenType): BinaryExpression {
-        const result: BinaryExpression = new BinaryExpression(global.generatedEs2panda._UpdateBinaryExpression(global.context, passNode(original), passNode(left), passNode(right), operatorType))
+        const result: BinaryExpression = new BinaryExpression(global.generatedEs2panda._UpdateBinaryExpression(global.context, passNode(original), passNode(left), passNode(right), operatorType), Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -108,5 +107,5 @@ export function isBinaryExpression(node: object | undefined): node is BinaryExpr
     return node instanceof BinaryExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION, (peer: KNativePointer) => new BinaryExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION, (peer: KNativePointer) => new BinaryExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION))
 }

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

@@ -37,17 +37,16 @@ import { Expression } from "./Expression"
 import { Statement } from "./Statement"
 
 export class BlockExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 157)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createBlockExpression(statements: readonly Statement[]): BlockExpression {
-        const result: BlockExpression = new BlockExpression(global.generatedEs2panda._CreateBlockExpression(global.context, passNodeArray(statements), statements.length))
+        const result: BlockExpression = new BlockExpression(global.generatedEs2panda._CreateBlockExpression(global.context, passNodeArray(statements), statements.length), Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateBlockExpression(original: BlockExpression | undefined, statements: readonly Statement[]): BlockExpression {
-        const result: BlockExpression = new BlockExpression(global.generatedEs2panda._UpdateBlockExpression(global.context, passNode(original), passNodeArray(statements), statements.length))
+        const result: BlockExpression = new BlockExpression(global.generatedEs2panda._UpdateBlockExpression(global.context, passNode(original), passNodeArray(statements), statements.length), Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -70,5 +69,5 @@ export function isBlockExpression(node: object | undefined): node is BlockExpres
     return node instanceof BlockExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_EXPRESSION, (peer: KNativePointer) => new BlockExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_EXPRESSION, (peer: KNativePointer) => new BlockExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_EXPRESSION))
 }

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

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Statement } from "./Statement"
 
 export class BlockStatement extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 7)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createBlockStatement(statementList: readonly Statement[]): BlockStatement {
-        const result: BlockStatement = new BlockStatement(global.generatedEs2panda._CreateBlockStatement(global.context, passNodeArray(statementList), statementList.length))
+        const result: BlockStatement = new BlockStatement(global.generatedEs2panda._CreateBlockStatement(global.context, passNodeArray(statementList), statementList.length), Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static updateBlockStatement(original: BlockStatement | undefined, statementList: readonly Statement[]): BlockStatement {
-        const result: BlockStatement = new BlockStatement(global.generatedEs2panda._UpdateBlockStatement(global.context, passNode(original), passNodeArray(statementList), statementList.length))
+        const result: BlockStatement = new BlockStatement(global.generatedEs2panda._UpdateBlockStatement(global.context, passNode(original), passNodeArray(statementList), statementList.length), Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
@@ -92,5 +91,5 @@ export function isBlockStatement(node: object | undefined): node is BlockStateme
     return node instanceof BlockStatement
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT, (peer: KNativePointer) => new BlockStatement(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT, (peer: KNativePointer) => new BlockStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT))
 }

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

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Literal } from "./Literal"
 
 export class BooleanLiteral extends Literal {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 8)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createBooleanLiteral(value: boolean): BooleanLiteral {
-        const result: BooleanLiteral = new BooleanLiteral(global.generatedEs2panda._CreateBooleanLiteral(global.context, value))
+        const result: BooleanLiteral = new BooleanLiteral(global.generatedEs2panda._CreateBooleanLiteral(global.context, value), Es2pandaAstNodeType.AST_NODE_TYPE_BOOLEAN_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
     static updateBooleanLiteral(original: BooleanLiteral | undefined, value: boolean): BooleanLiteral {
-        const result: BooleanLiteral = new BooleanLiteral(global.generatedEs2panda._UpdateBooleanLiteral(global.context, passNode(original), value))
+        const result: BooleanLiteral = new BooleanLiteral(global.generatedEs2panda._UpdateBooleanLiteral(global.context, passNode(original), value), Es2pandaAstNodeType.AST_NODE_TYPE_BOOLEAN_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
@@ -59,5 +58,5 @@ export function isBooleanLiteral(node: object | undefined): node is BooleanLiter
     return node instanceof BooleanLiteral
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_BOOLEAN_LITERAL)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BOOLEAN_LITERAL, (peer: KNativePointer) => new BooleanLiteral(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BOOLEAN_LITERAL, (peer: KNativePointer) => new BooleanLiteral(peer, Es2pandaAstNodeType.AST_NODE_TYPE_BOOLEAN_LITERAL))
 }

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

@@ -37,22 +37,21 @@ import { Identifier } from "./Identifier"
 import { Statement } from "./Statement"
 
 export class BreakStatement extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 9)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static create1BreakStatement(ident?: Identifier): BreakStatement {
-        const result: BreakStatement = new BreakStatement(global.generatedEs2panda._CreateBreakStatement1(global.context, passNode(ident)))
+        const result: BreakStatement = new BreakStatement(global.generatedEs2panda._CreateBreakStatement1(global.context, passNode(ident)), Es2pandaAstNodeType.AST_NODE_TYPE_BREAK_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static updateBreakStatement(original?: BreakStatement): BreakStatement {
-        const result: BreakStatement = new BreakStatement(global.generatedEs2panda._UpdateBreakStatement(global.context, passNode(original)))
+        const result: BreakStatement = new BreakStatement(global.generatedEs2panda._UpdateBreakStatement(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_BREAK_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static update1BreakStatement(original?: BreakStatement, ident?: Identifier): BreakStatement {
-        const result: BreakStatement = new BreakStatement(global.generatedEs2panda._UpdateBreakStatement1(global.context, passNode(original), passNode(ident)))
+        const result: BreakStatement = new BreakStatement(global.generatedEs2panda._UpdateBreakStatement1(global.context, passNode(original), passNode(ident)), Es2pandaAstNodeType.AST_NODE_TYPE_BREAK_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
@@ -76,5 +75,5 @@ export function isBreakStatement(node: object | undefined): node is BreakStateme
     return node instanceof BreakStatement
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_BREAK_STATEMENT)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BREAK_STATEMENT, (peer: KNativePointer) => new BreakStatement(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BREAK_STATEMENT, (peer: KNativePointer) => new BreakStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_BREAK_STATEMENT))
 }

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

@@ -39,12 +39,11 @@ import { MaybeOptionalExpression } from "./MaybeOptionalExpression"
 import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation"
 
 export class CallExpression extends MaybeOptionalExpression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 10)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createCallExpression(callee: Expression | undefined, _arguments: readonly Expression[], typeParams: TSTypeParameterInstantiation | undefined, optional_arg: boolean, trailingComma: boolean, trailingBlock?: BlockStatement): CallExpression {
-        const result: CallExpression = new CallExpression(global.generatedEs2panda._CreateCallExpression(global.context, passNode(callee), passNodeArray(_arguments), _arguments.length, passNode(typeParams), optional_arg, trailingComma))
+        const result: CallExpression = new CallExpression(global.generatedEs2panda._CreateCallExpression(global.context, passNode(callee), passNodeArray(_arguments), _arguments.length, passNode(typeParams), optional_arg, trailingComma), Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION)
         if (trailingBlock)
         {
             result.setTrailingBlock(trailingBlock)
@@ -53,7 +52,7 @@ export class CallExpression extends MaybeOptionalExpression {
         return result
     }
     static update1CallExpression(original?: CallExpression, other?: CallExpression, trailingBlock?: BlockStatement): CallExpression {
-        const result: CallExpression = new CallExpression(global.generatedEs2panda._UpdateCallExpression1(global.context, passNode(original), passNode(other)))
+        const result: CallExpression = new CallExpression(global.generatedEs2panda._UpdateCallExpression1(global.context, passNode(original), passNode(other)), Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION)
         if (trailingBlock)
         {
             result.setTrailingBlock(trailingBlock)
@@ -122,5 +121,5 @@ export function isCallExpression(node: object | undefined): node is CallExpressi
     return node instanceof CallExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION, (peer: KNativePointer) => new CallExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION, (peer: KNativePointer) => new CallExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION))
 }

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

@@ -38,22 +38,21 @@ import { Expression } from "./Expression"
 import { TypedStatement } from "./TypedStatement"
 
 export class CatchClause extends TypedStatement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 11)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createCatchClause(param?: Expression, body?: BlockStatement): CatchClause {
-        const result: CatchClause = new CatchClause(global.generatedEs2panda._CreateCatchClause(global.context, passNode(param), passNode(body)))
+        const result: CatchClause = new CatchClause(global.generatedEs2panda._CreateCatchClause(global.context, passNode(param), passNode(body)), Es2pandaAstNodeType.AST_NODE_TYPE_CATCH_CLAUSE)
         result.setChildrenParentPtr()
         return result
     }
     static updateCatchClause(original?: CatchClause, param?: Expression, body?: BlockStatement): CatchClause {
-        const result: CatchClause = new CatchClause(global.generatedEs2panda._UpdateCatchClause(global.context, passNode(original), passNode(param), passNode(body)))
+        const result: CatchClause = new CatchClause(global.generatedEs2panda._UpdateCatchClause(global.context, passNode(original), passNode(param), passNode(body)), Es2pandaAstNodeType.AST_NODE_TYPE_CATCH_CLAUSE)
         result.setChildrenParentPtr()
         return result
     }
     static update1CatchClause(original?: CatchClause, other?: CatchClause): CatchClause {
-        const result: CatchClause = new CatchClause(global.generatedEs2panda._UpdateCatchClause1(global.context, passNode(original), passNode(other)))
+        const result: CatchClause = new CatchClause(global.generatedEs2panda._UpdateCatchClause1(global.context, passNode(original), passNode(other)), Es2pandaAstNodeType.AST_NODE_TYPE_CATCH_CLAUSE)
         result.setChildrenParentPtr()
         return result
     }
@@ -72,5 +71,5 @@ export function isCatchClause(node: object | undefined): node is CatchClause {
     return node instanceof CatchClause
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CATCH_CLAUSE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CATCH_CLAUSE, (peer: KNativePointer) => new CatchClause(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CATCH_CLAUSE, (peer: KNativePointer) => new CatchClause(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CATCH_CLAUSE))
 }