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

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -33,33 +32,31 @@ import {
 } from "../../reexport-for-generated"
 
 import { AnnotatedExpression } from "./AnnotatedExpression"
-import { Decorator } from "./Decorator"
 import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 import { ValidationInfo } from "./ValidationInfo"
 
 export class Identifier extends AnnotatedExpression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 36)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static create2Identifier(name: string, typeAnnotation?: TypeNode): Identifier {
-        const result: Identifier = new Identifier(global.generatedEs2panda._CreateIdentifier2(global.context, name, passNode(typeAnnotation)))
+        const result: Identifier = new Identifier(global.generatedEs2panda._CreateIdentifier2(global.context, name, passNode(typeAnnotation)), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)
         result.setChildrenParentPtr()
         return result
     }
     static updateIdentifier(original?: Identifier): Identifier {
-        const result: Identifier = new Identifier(global.generatedEs2panda._UpdateIdentifier(global.context, passNode(original)))
+        const result: Identifier = new Identifier(global.generatedEs2panda._UpdateIdentifier(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)
         result.setChildrenParentPtr()
         return result
     }
     static update1Identifier(original: Identifier | undefined, name: string): Identifier {
-        const result: Identifier = new Identifier(global.generatedEs2panda._UpdateIdentifier1(global.context, passNode(original), name))
+        const result: Identifier = new Identifier(global.generatedEs2panda._UpdateIdentifier1(global.context, passNode(original), name), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)
         result.setChildrenParentPtr()
         return result
     }
     static update2Identifier(original: Identifier | undefined, name: string, typeAnnotation?: TypeNode): Identifier {
-        const result: Identifier = new Identifier(global.generatedEs2panda._UpdateIdentifier2(global.context, passNode(original), name, passNode(typeAnnotation)))
+        const result: Identifier = new Identifier(global.generatedEs2panda._UpdateIdentifier2(global.context, passNode(original), name, passNode(typeAnnotation)), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)
         result.setChildrenParentPtr()
         return result
     }
@@ -71,14 +68,6 @@ export class Identifier extends AnnotatedExpression {
         global.generatedEs2panda._IdentifierSetName(global.context, this.peer, newName)
         return this
     }
-    /** @deprecated */
-    setValueDecorators(source: Decorator | undefined, index: number): this {
-        global.generatedEs2panda._IdentifierSetValueDecorators(global.context, this.peer, passNode(source), index)
-        return this
-    }
-    get decorators(): readonly Decorator[] {
-        return unpackNodeArray(global.generatedEs2panda._IdentifierDecoratorsConst(global.context, this.peer))
-    }
     get isErrorPlaceHolder(): boolean {
         return global.generatedEs2panda._IdentifierIsErrorPlaceHolderConst(global.context, this.peer)
     }
@@ -169,5 +158,5 @@ export function isIdentifier(node: object | undefined): node is Identifier {
     return node instanceof Identifier
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER, (peer: KNativePointer) => new Identifier(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER, (peer: KNativePointer) => new Identifier(peer, Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER))
 }

package/build/libarkts-copy/src/generated/peers/IfStatement.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 IfStatement extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 38)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createIfStatement(test?: Expression, consequent?: Statement, alternate?: Statement): IfStatement {
-        const result: IfStatement = new IfStatement(global.generatedEs2panda._CreateIfStatement(global.context, passNode(test), passNode(consequent), passNode(alternate)))
+        const result: IfStatement = new IfStatement(global.generatedEs2panda._CreateIfStatement(global.context, passNode(test), passNode(consequent), passNode(alternate)), Es2pandaAstNodeType.AST_NODE_TYPE_IF_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static updateIfStatement(original?: IfStatement, test?: Expression, consequent?: Statement, alternate?: Statement): IfStatement {
-        const result: IfStatement = new IfStatement(global.generatedEs2panda._UpdateIfStatement(global.context, passNode(original), passNode(test), passNode(consequent), passNode(alternate)))
+        const result: IfStatement = new IfStatement(global.generatedEs2panda._UpdateIfStatement(global.context, passNode(original), passNode(test), passNode(consequent), passNode(alternate)), Es2pandaAstNodeType.AST_NODE_TYPE_IF_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
@@ -76,5 +74,5 @@ export function isIfStatement(node: object | undefined): node is IfStatement {
     return node instanceof IfStatement
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_IF_STATEMENT)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_IF_STATEMENT, (peer: KNativePointer) => new IfStatement(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_IF_STATEMENT, (peer: KNativePointer) => new IfStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_IF_STATEMENT))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -38,17 +37,16 @@ import { Statement } from "./Statement"
 import { StringLiteral } from "./StringLiteral"
 
 export class ImportDeclaration extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 39)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createImportDeclaration(source: StringLiteral | undefined, specifiers: readonly AstNode[], importKinds: Es2pandaImportKinds): ImportDeclaration {
-        const result: ImportDeclaration = new ImportDeclaration(global.generatedEs2panda._CreateImportDeclaration(global.context, passNode(source), passNodeArray(specifiers), specifiers.length, importKinds))
+        const result: ImportDeclaration = new ImportDeclaration(global.generatedEs2panda._CreateImportDeclaration(global.context, passNode(source), passNodeArray(specifiers), specifiers.length, importKinds), Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     static updateImportDeclaration(original: ImportDeclaration | undefined, source: StringLiteral | undefined, specifiers: readonly AstNode[], importKinds: Es2pandaImportKinds): ImportDeclaration {
-        const result: ImportDeclaration = new ImportDeclaration(global.generatedEs2panda._UpdateImportDeclaration(global.context, passNode(original), passNode(source), passNodeArray(specifiers), specifiers.length, importKinds))
+        const result: ImportDeclaration = new ImportDeclaration(global.generatedEs2panda._UpdateImportDeclaration(global.context, passNode(original), passNode(source), passNodeArray(specifiers), specifiers.length, importKinds), Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
@@ -71,7 +69,7 @@ export class ImportDeclaration extends Statement {
         return unpackNodeArray(global.generatedEs2panda._ImportDeclarationSpecifiersForUpdate(global.context, this.peer))
     }
     get source(): StringLiteral | undefined {
-        return unpackNode(global.generatedEs2panda._ImportDeclarationSource(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ImportDeclarationSource(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL)
     }
     get specifiers(): readonly AstNode[] {
         return unpackNodeArray(global.generatedEs2panda._ImportDeclarationSpecifiersConst(global.context, this.peer))
@@ -85,5 +83,5 @@ export function isImportDeclaration(node: object | undefined): node is ImportDec
     return node instanceof ImportDeclaration
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DECLARATION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DECLARATION, (peer: KNativePointer) => new ImportDeclaration(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DECLARATION, (peer: KNativePointer) => new ImportDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DECLARATION))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,22 +36,21 @@ import { Identifier } from "./Identifier"
 import { Statement } from "./Statement"
 
 export class ImportDefaultSpecifier extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 41)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createImportDefaultSpecifier(local?: Identifier): ImportDefaultSpecifier {
-        const result: ImportDefaultSpecifier = new ImportDefaultSpecifier(global.generatedEs2panda._CreateImportDefaultSpecifier(global.context, passNode(local)))
+        const result: ImportDefaultSpecifier = new ImportDefaultSpecifier(global.generatedEs2panda._CreateImportDefaultSpecifier(global.context, passNode(local)), Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DEFAULT_SPECIFIER)
         result.setChildrenParentPtr()
         return result
     }
     static updateImportDefaultSpecifier(original?: ImportDefaultSpecifier, local?: Identifier): ImportDefaultSpecifier {
-        const result: ImportDefaultSpecifier = new ImportDefaultSpecifier(global.generatedEs2panda._UpdateImportDefaultSpecifier(global.context, passNode(original), passNode(local)))
+        const result: ImportDefaultSpecifier = new ImportDefaultSpecifier(global.generatedEs2panda._UpdateImportDefaultSpecifier(global.context, passNode(original), passNode(local)), Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DEFAULT_SPECIFIER)
         result.setChildrenParentPtr()
         return result
     }
     get local(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._ImportDefaultSpecifierLocal(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ImportDefaultSpecifierLocal(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)
     }
     protected readonly brandImportDefaultSpecifier: undefined
 }
@@ -60,5 +58,5 @@ export function isImportDefaultSpecifier(node: object | undefined): node is Impo
     return node instanceof ImportDefaultSpecifier
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DEFAULT_SPECIFIER)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DEFAULT_SPECIFIER, (peer: KNativePointer) => new ImportDefaultSpecifier(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DEFAULT_SPECIFIER, (peer: KNativePointer) => new ImportDefaultSpecifier(peer, Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DEFAULT_SPECIFIER))
 }

package/build/libarkts-copy/src/generated/peers/ImportExpression.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 ImportExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 40)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createImportExpression(source?: Expression): ImportExpression {
-        const result: ImportExpression = new ImportExpression(global.generatedEs2panda._CreateImportExpression(global.context, passNode(source)))
+        const result: ImportExpression = new ImportExpression(global.generatedEs2panda._CreateImportExpression(global.context, passNode(source)), Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateImportExpression(original?: ImportExpression, source?: Expression): ImportExpression {
-        const result: ImportExpression = new ImportExpression(global.generatedEs2panda._UpdateImportExpression(global.context, passNode(original), passNode(source)))
+        const result: ImportExpression = new ImportExpression(global.generatedEs2panda._UpdateImportExpression(global.context, passNode(original), passNode(source)), Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -59,5 +57,5 @@ export function isImportExpression(node: object | undefined): node is ImportExpr
     return node instanceof ImportExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_EXPRESSION, (peer: KNativePointer) => new ImportExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_EXPRESSION, (peer: KNativePointer) => new ImportExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_EXPRESSION))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,22 +36,21 @@ import { Identifier } from "./Identifier"
 import { Statement } from "./Statement"
 
 export class ImportNamespaceSpecifier extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 42)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createImportNamespaceSpecifier(local?: Identifier): ImportNamespaceSpecifier {
-        const result: ImportNamespaceSpecifier = new ImportNamespaceSpecifier(global.generatedEs2panda._CreateImportNamespaceSpecifier(global.context, passNode(local)))
+        const result: ImportNamespaceSpecifier = new ImportNamespaceSpecifier(global.generatedEs2panda._CreateImportNamespaceSpecifier(global.context, passNode(local)), Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_NAMESPACE_SPECIFIER)
         result.setChildrenParentPtr()
         return result
     }
     static updateImportNamespaceSpecifier(original?: ImportNamespaceSpecifier, local?: Identifier): ImportNamespaceSpecifier {
-        const result: ImportNamespaceSpecifier = new ImportNamespaceSpecifier(global.generatedEs2panda._UpdateImportNamespaceSpecifier(global.context, passNode(original), passNode(local)))
+        const result: ImportNamespaceSpecifier = new ImportNamespaceSpecifier(global.generatedEs2panda._UpdateImportNamespaceSpecifier(global.context, passNode(original), passNode(local)), Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_NAMESPACE_SPECIFIER)
         result.setChildrenParentPtr()
         return result
     }
     get local(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._ImportNamespaceSpecifierLocal(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ImportNamespaceSpecifierLocal(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)
     }
     protected readonly brandImportNamespaceSpecifier: undefined
 }
@@ -60,5 +58,5 @@ export function isImportNamespaceSpecifier(node: object | undefined): node is Im
     return node instanceof ImportNamespaceSpecifier
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_NAMESPACE_SPECIFIER)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_NAMESPACE_SPECIFIER, (peer: KNativePointer) => new ImportNamespaceSpecifier(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_NAMESPACE_SPECIFIER, (peer: KNativePointer) => new ImportNamespaceSpecifier(peer, Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_NAMESPACE_SPECIFIER))
 }

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

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

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,25 +36,24 @@ import { Identifier } from "./Identifier"
 import { Statement } from "./Statement"
 
 export class ImportSpecifier extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 43)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createImportSpecifier(imported?: Identifier, local?: Identifier): ImportSpecifier {
-        const result: ImportSpecifier = new ImportSpecifier(global.generatedEs2panda._CreateImportSpecifier(global.context, passNode(imported), passNode(local)))
+        const result: ImportSpecifier = new ImportSpecifier(global.generatedEs2panda._CreateImportSpecifier(global.context, passNode(imported), passNode(local)), Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_SPECIFIER)
         result.setChildrenParentPtr()
         return result
     }
     static updateImportSpecifier(original?: ImportSpecifier, imported?: Identifier, local?: Identifier): ImportSpecifier {
-        const result: ImportSpecifier = new ImportSpecifier(global.generatedEs2panda._UpdateImportSpecifier(global.context, passNode(original), passNode(imported), passNode(local)))
+        const result: ImportSpecifier = new ImportSpecifier(global.generatedEs2panda._UpdateImportSpecifier(global.context, passNode(original), passNode(imported), passNode(local)), Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_SPECIFIER)
         result.setChildrenParentPtr()
         return result
     }
     get imported(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._ImportSpecifierImported(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ImportSpecifierImported(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)
     }
     get local(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._ImportSpecifierLocal(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ImportSpecifierLocal(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)
     }
     get isRemovable(): boolean {
         return global.generatedEs2panda._ImportSpecifierIsRemovableConst(global.context, this.peer)
@@ -71,5 +69,5 @@ export function isImportSpecifier(node: object | undefined): node is ImportSpeci
     return node instanceof ImportSpecifier
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_SPECIFIER)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_SPECIFIER, (peer: KNativePointer) => new ImportSpecifier(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_SPECIFIER, (peer: KNativePointer) => new ImportSpecifier(peer, Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_SPECIFIER))
 }

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

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

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

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

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,17 +36,16 @@ import { Identifier } from "./Identifier"
 import { Statement } from "./Statement"
 
 export class LabelledStatement extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 44)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createLabelledStatement(ident?: Identifier, body?: Statement): LabelledStatement {
-        const result: LabelledStatement = new LabelledStatement(global.generatedEs2panda._CreateLabelledStatement(global.context, passNode(ident), passNode(body)))
+        const result: LabelledStatement = new LabelledStatement(global.generatedEs2panda._CreateLabelledStatement(global.context, passNode(ident), passNode(body)), Es2pandaAstNodeType.AST_NODE_TYPE_LABELLED_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static updateLabelledStatement(original?: LabelledStatement, ident?: Identifier, body?: Statement): LabelledStatement {
-        const result: LabelledStatement = new LabelledStatement(global.generatedEs2panda._UpdateLabelledStatement(global.context, passNode(original), passNode(ident), passNode(body)))
+        const result: LabelledStatement = new LabelledStatement(global.generatedEs2panda._UpdateLabelledStatement(global.context, passNode(original), passNode(ident), passNode(body)), Es2pandaAstNodeType.AST_NODE_TYPE_LABELLED_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
@@ -55,7 +53,7 @@ export class LabelledStatement extends Statement {
         return unpackNode(global.generatedEs2panda._LabelledStatementBody(global.context, this.peer))
     }
     get ident(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._LabelledStatementIdent(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._LabelledStatementIdent(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)
     }
     get referencedStatement(): AstNode | undefined {
         return unpackNode(global.generatedEs2panda._LabelledStatementGetReferencedStatementConst(global.context, this.peer))
@@ -66,5 +64,5 @@ export function isLabelledStatement(node: object | undefined): node is LabelledS
     return node instanceof LabelledStatement
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_LABELLED_STATEMENT)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_LABELLED_STATEMENT, (peer: KNativePointer) => new LabelledStatement(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_LABELLED_STATEMENT, (peer: KNativePointer) => new LabelledStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_LABELLED_STATEMENT))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -32,11 +31,12 @@ import {
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 
 export class Literal extends Expression {
-    constructor(pointer: KNativePointer) {
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     get isFolded(): boolean {
         return global.generatedEs2panda._LiteralIsFoldedConst(global.context, this.peer)

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -32,11 +31,12 @@ import {
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Statement } from "./Statement"
 
 export class LoopStatement extends Statement {
-    constructor(pointer: KNativePointer) {
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     protected readonly brandLoopStatement: undefined
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -32,11 +31,12 @@ import {
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 
 export class MaybeOptionalExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     get isOptional(): boolean {
         return global.generatedEs2panda._MaybeOptionalExpressionIsOptionalConst(global.context, this.peer)

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -33,7 +32,6 @@ import {
 } from "../../reexport-for-generated"
 
 import { CodeGen } from "./CodeGen"
-import { ETSFunctionType } from "./ETSFunctionType"
 import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Es2pandaMemberExpressionKind } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
@@ -41,17 +39,16 @@ import { MaybeOptionalExpression } from "./MaybeOptionalExpression"
 import { VReg } from "./VReg"
 
 export class MemberExpression extends MaybeOptionalExpression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 45)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createMemberExpression(object_arg: Expression | undefined, property: Expression | undefined, kind: Es2pandaMemberExpressionKind, computed: boolean, optional_arg: boolean): MemberExpression {
-        const result: MemberExpression = new MemberExpression(global.generatedEs2panda._CreateMemberExpression(global.context, passNode(object_arg), passNode(property), kind, computed, optional_arg))
+        const result: MemberExpression = new MemberExpression(global.generatedEs2panda._CreateMemberExpression(global.context, passNode(object_arg), passNode(property), kind, computed, optional_arg), Es2pandaAstNodeType.AST_NODE_TYPE_MEMBER_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateMemberExpression(original: MemberExpression | undefined, object_arg: Expression | undefined, property: Expression | undefined, kind: Es2pandaMemberExpressionKind, computed: boolean, optional_arg: boolean): MemberExpression {
-        const result: MemberExpression = new MemberExpression(global.generatedEs2panda._UpdateMemberExpression(global.context, passNode(original), passNode(object_arg), passNode(property), kind, computed, optional_arg))
+        const result: MemberExpression = new MemberExpression(global.generatedEs2panda._UpdateMemberExpression(global.context, passNode(original), passNode(object_arg), passNode(property), kind, computed, optional_arg), Es2pandaAstNodeType.AST_NODE_TYPE_MEMBER_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -87,9 +84,6 @@ export class MemberExpression extends MaybeOptionalExpression {
         global.generatedEs2panda._MemberExpressionRemoveMemberKind(global.context, this.peer, kind)
         return this
     }
-    get extensionAccessorType(): ETSFunctionType | undefined {
-        return unpackNode(global.generatedEs2panda._MemberExpressionExtensionAccessorTypeConst(global.context, this.peer))
-    }
     get isIgnoreBox(): boolean {
         return global.generatedEs2panda._MemberExpressionIsIgnoreBoxConst(global.context, this.peer)
     }
@@ -117,5 +111,5 @@ export function isMemberExpression(node: object | undefined): node is MemberExpr
     return node instanceof MemberExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_MEMBER_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_MEMBER_EXPRESSION, (peer: KNativePointer) => new MemberExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_MEMBER_EXPRESSION, (peer: KNativePointer) => new MemberExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_MEMBER_EXPRESSION))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,17 +36,16 @@ import { Es2pandaMetaPropertyKind } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 
 export class MetaProperty extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 46)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createMetaProperty(kind: Es2pandaMetaPropertyKind): MetaProperty {
-        const result: MetaProperty = new MetaProperty(global.generatedEs2panda._CreateMetaProperty(global.context, kind))
+        const result: MetaProperty = new MetaProperty(global.generatedEs2panda._CreateMetaProperty(global.context, kind), Es2pandaAstNodeType.AST_NODE_TYPE_META_PROPERTY_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateMetaProperty(original: MetaProperty | undefined, kind: Es2pandaMetaPropertyKind): MetaProperty {
-        const result: MetaProperty = new MetaProperty(global.generatedEs2panda._UpdateMetaProperty(global.context, passNode(original), kind))
+        const result: MetaProperty = new MetaProperty(global.generatedEs2panda._UpdateMetaProperty(global.context, passNode(original), kind), Es2pandaAstNodeType.AST_NODE_TYPE_META_PROPERTY_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -60,5 +58,5 @@ export function isMetaProperty(node: object | undefined): node is MetaProperty {
     return node instanceof MetaProperty
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_META_PROPERTY_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_META_PROPERTY_EXPRESSION, (peer: KNativePointer) => new MetaProperty(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_META_PROPERTY_EXPRESSION, (peer: KNativePointer) => new MetaProperty(peer, Es2pandaAstNodeType.AST_NODE_TYPE_META_PROPERTY_EXPRESSION))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -42,12 +41,11 @@ import { extension_MethodDefinitionOnUpdate } from "./../../reexport-for-generat
 import { extension_MethodDefinitionSetChildrenParentPtr } from "./../../reexport-for-generated"
 
 export class MethodDefinition extends ClassElement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 47)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createMethodDefinition(kind: Es2pandaMethodDefinitionKind, key: Expression | undefined, value: Expression | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean, overloads?: readonly MethodDefinition[]): MethodDefinition {
-        const result: MethodDefinition = new MethodDefinition(global.generatedEs2panda._CreateMethodDefinition(global.context, kind, passNode(key), passNode(value), modifiers, isComputed))
+        const result: MethodDefinition = new MethodDefinition(global.generatedEs2panda._CreateMethodDefinition(global.context, kind, passNode(key), passNode(value), modifiers, isComputed), Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION)
         if (overloads)
         {
             result.setOverloads(overloads)
@@ -56,7 +54,7 @@ export class MethodDefinition extends ClassElement {
         return result
     }
     static updateMethodDefinition(original: MethodDefinition | undefined, kind: Es2pandaMethodDefinitionKind, key: Expression | undefined, value: Expression | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean, overloads?: readonly MethodDefinition[]): MethodDefinition {
-        const result: MethodDefinition = new MethodDefinition(global.generatedEs2panda._UpdateMethodDefinition(global.context, passNode(original), kind, passNode(key), passNode(value), modifiers, isComputed))
+        const result: MethodDefinition = new MethodDefinition(global.generatedEs2panda._UpdateMethodDefinition(global.context, passNode(original), kind, passNode(key), passNode(value), modifiers, isComputed), Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION)
         if (overloads)
         {
             result.setOverloads(overloads)
@@ -91,13 +89,13 @@ export class MethodDefinition extends ClassElement {
         return this
     }
     get overloads(): readonly MethodDefinition[] {
-        return unpackNodeArray(global.generatedEs2panda._MethodDefinitionOverloadsConst(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._MethodDefinitionOverloadsConst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION)
     }
     get baseOverloadMethod(): MethodDefinition | undefined {
-        return unpackNode(global.generatedEs2panda._MethodDefinitionBaseOverloadMethod(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._MethodDefinitionBaseOverloadMethod(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION)
     }
     get asyncPairMethod(): MethodDefinition | undefined {
-        return unpackNode(global.generatedEs2panda._MethodDefinitionAsyncPairMethod(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._MethodDefinitionAsyncPairMethod(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION)
     }
     /** @deprecated */
     setOverloads(overloads: readonly MethodDefinition[]): this {
@@ -119,8 +117,8 @@ export class MethodDefinition extends ClassElement {
         global.generatedEs2panda._MethodDefinitionSetAsyncPairMethod(global.context, this.peer, passNode(asyncPairMethod))
         return this
     }
-    get function(): ScriptFunction | undefined {
-        return unpackNode(global.generatedEs2panda._MethodDefinitionFunction(global.context, this.peer))
+    get function(): ScriptFunction {
+        return unpackNonNullableNode(global.generatedEs2panda._MethodDefinitionFunction(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION)
     }
     /** @deprecated */
     initializeOverloadInfo(): this {
@@ -150,5 +148,5 @@ export function isMethodDefinition(node: object | undefined): node is MethodDefi
     return node instanceof MethodDefinition
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION, (peer: KNativePointer) => new MethodDefinition(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION, (peer: KNativePointer) => new MethodDefinition(peer, Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION))
 }