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

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

@@ -37,17 +37,16 @@ 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
     }
@@ -71,5 +70,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/LabelledStatement.ts

@@ -37,17 +37,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
     }
@@ -66,5 +65,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

@@ -32,11 +32,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

@@ -32,11 +32,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

@@ -32,11 +32,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

@@ -33,7 +33,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 +40,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 +85,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 +112,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

@@ -37,17 +37,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 +59,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

@@ -42,12 +42,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 +55,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)
@@ -150,5 +149,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))
 }

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

@@ -38,17 +38,16 @@ import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation"
 import { TypeNode } from "./TypeNode"
 
 export class NamedType extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 48)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createNamedType(name?: Identifier): NamedType {
-        const result: NamedType = new NamedType(global.generatedEs2panda._CreateNamedType(global.context, passNode(name)))
+        const result: NamedType = new NamedType(global.generatedEs2panda._CreateNamedType(global.context, passNode(name)), Es2pandaAstNodeType.AST_NODE_TYPE_NAMED_TYPE)
         result.setChildrenParentPtr()
         return result
     }
     static updateNamedType(original?: NamedType, name?: Identifier): NamedType {
-        const result: NamedType = new NamedType(global.generatedEs2panda._UpdateNamedType(global.context, passNode(original), passNode(name)))
+        const result: NamedType = new NamedType(global.generatedEs2panda._UpdateNamedType(global.context, passNode(original), passNode(name)), Es2pandaAstNodeType.AST_NODE_TYPE_NAMED_TYPE)
         result.setChildrenParentPtr()
         return result
     }
@@ -82,5 +81,5 @@ export function isNamedType(node: object | undefined): node is NamedType {
     return node instanceof NamedType
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_NAMED_TYPE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_NAMED_TYPE, (peer: KNativePointer) => new NamedType(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_NAMED_TYPE, (peer: KNativePointer) => new NamedType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_NAMED_TYPE))
 }

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

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 
 export class NewExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 49)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createNewExpression(callee: Expression | undefined, _arguments: readonly Expression[]): NewExpression {
-        const result: NewExpression = new NewExpression(global.generatedEs2panda._CreateNewExpression(global.context, passNode(callee), passNodeArray(_arguments), _arguments.length))
+        const result: NewExpression = new NewExpression(global.generatedEs2panda._CreateNewExpression(global.context, passNode(callee), passNodeArray(_arguments), _arguments.length), Es2pandaAstNodeType.AST_NODE_TYPE_NEW_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateNewExpression(original: NewExpression | undefined, callee: Expression | undefined, _arguments: readonly Expression[]): NewExpression {
-        const result: NewExpression = new NewExpression(global.generatedEs2panda._UpdateNewExpression(global.context, passNode(original), passNode(callee), passNodeArray(_arguments), _arguments.length))
+        const result: NewExpression = new NewExpression(global.generatedEs2panda._UpdateNewExpression(global.context, passNode(original), passNode(callee), passNodeArray(_arguments), _arguments.length), Es2pandaAstNodeType.AST_NODE_TYPE_NEW_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -62,5 +61,5 @@ export function isNewExpression(node: object | undefined): node is NewExpression
     return node instanceof NewExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_NEW_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_NEW_EXPRESSION, (peer: KNativePointer) => new NewExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_NEW_EXPRESSION, (peer: KNativePointer) => new NewExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_NEW_EXPRESSION))
 }

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

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Literal } from "./Literal"
 
 export class NullLiteral extends Literal {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 50)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createNullLiteral(): NullLiteral {
-        const result: NullLiteral = new NullLiteral(global.generatedEs2panda._CreateNullLiteral(global.context))
+        const result: NullLiteral = new NullLiteral(global.generatedEs2panda._CreateNullLiteral(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_NULL_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
     static updateNullLiteral(original?: NullLiteral): NullLiteral {
-        const result: NullLiteral = new NullLiteral(global.generatedEs2panda._UpdateNullLiteral(global.context, passNode(original)))
+        const result: NullLiteral = new NullLiteral(global.generatedEs2panda._UpdateNullLiteral(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_NULL_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +55,5 @@ export function isNullLiteral(node: object | undefined): node is NullLiteral {
     return node instanceof NullLiteral
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_NULL_LITERAL)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_NULL_LITERAL, (peer: KNativePointer) => new NullLiteral(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_NULL_LITERAL, (peer: KNativePointer) => new NullLiteral(peer, Es2pandaAstNodeType.AST_NODE_TYPE_NULL_LITERAL))
 }

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

@@ -34,45 +34,46 @@ import {
 
 import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Literal } from "./Literal"
+import { extension_NumberLiteralValue } from "./../../reexport-for-generated"
 
 export class NumberLiteral extends Literal {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 52)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createNumberLiteral(value: number): AstNode {
-        const result: NumberLiteral = new NumberLiteral(global.generatedEs2panda._CreateNumberLiteral(global.context, value))
+        const result: NumberLiteral = new NumberLiteral(global.generatedEs2panda._CreateNumberLiteral(global.context, value), Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
     static updateNumberLiteral(original: AstNode | undefined, value: number): AstNode {
-        const result: NumberLiteral = new NumberLiteral(global.generatedEs2panda._UpdateNumberLiteral(global.context, passNode(original), value))
+        const result: NumberLiteral = new NumberLiteral(global.generatedEs2panda._UpdateNumberLiteral(global.context, passNode(original), value), Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
     static update1NumberLiteral(original: AstNode | undefined, value: number): AstNode {
-        const result: NumberLiteral = new NumberLiteral(global.generatedEs2panda._UpdateNumberLiteral1(global.context, passNode(original), value))
+        const result: NumberLiteral = new NumberLiteral(global.generatedEs2panda._UpdateNumberLiteral1(global.context, passNode(original), value), Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
     static update2NumberLiteral(original: AstNode | undefined, value: number): AstNode {
-        const result: NumberLiteral = new NumberLiteral(global.generatedEs2panda._UpdateNumberLiteral2(global.context, passNode(original), value))
+        const result: NumberLiteral = new NumberLiteral(global.generatedEs2panda._UpdateNumberLiteral2(global.context, passNode(original), value), Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
     static update3NumberLiteral(original: AstNode | undefined, value: number): AstNode {
-        const result: NumberLiteral = new NumberLiteral(global.generatedEs2panda._UpdateNumberLiteral3(global.context, passNode(original), value))
+        const result: NumberLiteral = new NumberLiteral(global.generatedEs2panda._UpdateNumberLiteral3(global.context, passNode(original), value), Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
     get str(): string {
         return unpackString(global.generatedEs2panda._NumberLiteralStrConst(global.context, this.peer))
     }
+    value = extension_NumberLiteralValue
     protected readonly brandNumberLiteral: undefined
 }
 export function isNumberLiteral(node: object | undefined): node is NumberLiteral {
     return node instanceof NumberLiteral
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL, (peer: KNativePointer) => new NumberLiteral(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL, (peer: KNativePointer) => new NumberLiteral(peer, Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL))
 }

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

@@ -40,17 +40,16 @@ import { TypeNode } from "./TypeNode"
 import { ValidationInfo } from "./ValidationInfo"
 
 export class ObjectExpression extends AnnotatedExpression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 163)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createObjectExpression(nodeType: Es2pandaAstNodeType, properties: readonly Expression[], trailingComma: boolean): ObjectExpression {
-        const result: ObjectExpression = new ObjectExpression(global.generatedEs2panda._CreateObjectExpression(global.context, nodeType, passNodeArray(properties), properties.length, trailingComma))
+        const result: ObjectExpression = new ObjectExpression(global.generatedEs2panda._CreateObjectExpression(global.context, nodeType, passNodeArray(properties), properties.length, trailingComma), Es2pandaAstNodeType.AST_NODE_TYPE_OBJECT_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateObjectExpression(original: ObjectExpression | undefined, nodeType: Es2pandaAstNodeType, properties: readonly Expression[], trailingComma: boolean): ObjectExpression {
-        const result: ObjectExpression = new ObjectExpression(global.generatedEs2panda._UpdateObjectExpression(global.context, passNode(original), nodeType, passNodeArray(properties), properties.length, trailingComma))
+        const result: ObjectExpression = new ObjectExpression(global.generatedEs2panda._UpdateObjectExpression(global.context, passNode(original), nodeType, passNodeArray(properties), properties.length, trailingComma), Es2pandaAstNodeType.AST_NODE_TYPE_OBJECT_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -96,5 +95,5 @@ export function isObjectExpression(node: object | undefined): node is ObjectExpr
     return node instanceof ObjectExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_OBJECT_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_OBJECT_EXPRESSION, (peer: KNativePointer) => new ObjectExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_OBJECT_EXPRESSION, (peer: KNativePointer) => new ObjectExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_OBJECT_EXPRESSION))
 }

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

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 
 export class OmittedExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 53)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createOmittedExpression(): OmittedExpression {
-        const result: OmittedExpression = new OmittedExpression(global.generatedEs2panda._CreateOmittedExpression(global.context))
+        const result: OmittedExpression = new OmittedExpression(global.generatedEs2panda._CreateOmittedExpression(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_OMITTED_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateOmittedExpression(original?: OmittedExpression): OmittedExpression {
-        const result: OmittedExpression = new OmittedExpression(global.generatedEs2panda._UpdateOmittedExpression(global.context, passNode(original)))
+        const result: OmittedExpression = new OmittedExpression(global.generatedEs2panda._UpdateOmittedExpression(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_OMITTED_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +55,5 @@ export function isOmittedExpression(node: object | undefined): node is OmittedEx
     return node instanceof OmittedExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_OMITTED_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_OMITTED_EXPRESSION, (peer: KNativePointer) => new OmittedExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_OMITTED_EXPRESSION, (peer: KNativePointer) => new OmittedExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_OMITTED_EXPRESSION))
 }

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

@@ -36,17 +36,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 
 export class OpaqueTypeNode extends TypeNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 156)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static create1OpaqueTypeNode(): OpaqueTypeNode {
-        const result: OpaqueTypeNode = new OpaqueTypeNode(global.generatedEs2panda._CreateOpaqueTypeNode1(global.context))
+        const result: OpaqueTypeNode = new OpaqueTypeNode(global.generatedEs2panda._CreateOpaqueTypeNode1(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_OPAQUE_TYPE_NODE)
         result.setChildrenParentPtr()
         return result
     }
     static update1OpaqueTypeNode(original?: OpaqueTypeNode): OpaqueTypeNode {
-        const result: OpaqueTypeNode = new OpaqueTypeNode(global.generatedEs2panda._UpdateOpaqueTypeNode1(global.context, passNode(original)))
+        const result: OpaqueTypeNode = new OpaqueTypeNode(global.generatedEs2panda._UpdateOpaqueTypeNode1(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_OPAQUE_TYPE_NODE)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +55,5 @@ export function isOpaqueTypeNode(node: object | undefined): node is OpaqueTypeNo
     return node instanceof OpaqueTypeNode
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_OPAQUE_TYPE_NODE)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_OPAQUE_TYPE_NODE, (peer: KNativePointer) => new OpaqueTypeNode(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_OPAQUE_TYPE_NODE, (peer: KNativePointer) => new OpaqueTypeNode(peer, Es2pandaAstNodeType.AST_NODE_TYPE_OPAQUE_TYPE_NODE))
 }

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

@@ -41,17 +41,16 @@ import { Identifier } from "./Identifier"
 import { SrcDumper } from "./SrcDumper"
 
 export class OverloadDeclaration extends ClassElement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 54)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createOverloadDeclaration(key: Expression | undefined, modifiers: Es2pandaModifierFlags): OverloadDeclaration {
-        const result: OverloadDeclaration = new OverloadDeclaration(global.generatedEs2panda._CreateOverloadDeclaration(global.context, passNode(key), modifiers))
+        const result: OverloadDeclaration = new OverloadDeclaration(global.generatedEs2panda._CreateOverloadDeclaration(global.context, passNode(key), modifiers), Es2pandaAstNodeType.AST_NODE_TYPE_OVERLOAD_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     static updateOverloadDeclaration(original: OverloadDeclaration | undefined, key: Expression | undefined, modifiers: Es2pandaModifierFlags): OverloadDeclaration {
-        const result: OverloadDeclaration = new OverloadDeclaration(global.generatedEs2panda._UpdateOverloadDeclaration(global.context, passNode(original), passNode(key), modifiers))
+        const result: OverloadDeclaration = new OverloadDeclaration(global.generatedEs2panda._UpdateOverloadDeclaration(global.context, passNode(original), passNode(key), modifiers), Es2pandaAstNodeType.AST_NODE_TYPE_OVERLOAD_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
@@ -99,5 +98,5 @@ export function isOverloadDeclaration(node: object | undefined): node is Overloa
     return node instanceof OverloadDeclaration
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_OVERLOAD_DECLARATION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_OVERLOAD_DECLARATION, (peer: KNativePointer) => new OverloadDeclaration(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_OVERLOAD_DECLARATION, (peer: KNativePointer) => new OverloadDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_OVERLOAD_DECLARATION))
 }

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

@@ -37,17 +37,16 @@ import { Expression } from "./Expression"
 import { TypeNode } from "./TypeNode"
 
 export class PrefixAssertionExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 55)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createPrefixAssertionExpression(expr?: Expression, type?: TypeNode): PrefixAssertionExpression {
-        const result: PrefixAssertionExpression = new PrefixAssertionExpression(global.generatedEs2panda._CreatePrefixAssertionExpression(global.context, passNode(expr), passNode(type)))
+        const result: PrefixAssertionExpression = new PrefixAssertionExpression(global.generatedEs2panda._CreatePrefixAssertionExpression(global.context, passNode(expr), passNode(type)), Es2pandaAstNodeType.AST_NODE_TYPE_PREFIX_ASSERTION_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updatePrefixAssertionExpression(original?: PrefixAssertionExpression, expr?: Expression, type?: TypeNode): PrefixAssertionExpression {
-        const result: PrefixAssertionExpression = new PrefixAssertionExpression(global.generatedEs2panda._UpdatePrefixAssertionExpression(global.context, passNode(original), passNode(expr), passNode(type)))
+        const result: PrefixAssertionExpression = new PrefixAssertionExpression(global.generatedEs2panda._UpdatePrefixAssertionExpression(global.context, passNode(original), passNode(expr), passNode(type)), Es2pandaAstNodeType.AST_NODE_TYPE_PREFIX_ASSERTION_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -63,5 +62,5 @@ export function isPrefixAssertionExpression(node: object | undefined): node is P
     return node instanceof PrefixAssertionExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_PREFIX_ASSERTION_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_PREFIX_ASSERTION_EXPRESSION, (peer: KNativePointer) => new PrefixAssertionExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_PREFIX_ASSERTION_EXPRESSION, (peer: KNativePointer) => new PrefixAssertionExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_PREFIX_ASSERTION_EXPRESSION))
 }

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

@@ -38,22 +38,21 @@ import { Expression } from "./Expression"
 import { ValidationInfo } from "./ValidationInfo"
 
 export class Property extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 56)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static create1Property(kind: Es2pandaPropertyKind, key: Expression | undefined, value: Expression | undefined, isMethod: boolean, isComputed: boolean): Property {
-        const result: Property = new Property(global.generatedEs2panda._CreateProperty1(global.context, kind, passNode(key), passNode(value), isMethod, isComputed))
+        const result: Property = new Property(global.generatedEs2panda._CreateProperty1(global.context, kind, passNode(key), passNode(value), isMethod, isComputed), Es2pandaAstNodeType.AST_NODE_TYPE_PROPERTY)
         result.setChildrenParentPtr()
         return result
     }
     static updateProperty(original?: Property, key?: Expression, value?: Expression): Property {
-        const result: Property = new Property(global.generatedEs2panda._UpdateProperty(global.context, passNode(original), passNode(key), passNode(value)))
+        const result: Property = new Property(global.generatedEs2panda._UpdateProperty(global.context, passNode(original), passNode(key), passNode(value)), Es2pandaAstNodeType.AST_NODE_TYPE_PROPERTY)
         result.setChildrenParentPtr()
         return result
     }
     static update1Property(original: Property | undefined, kind: Es2pandaPropertyKind, key: Expression | undefined, value: Expression | undefined, isMethod: boolean, isComputed: boolean): Property {
-        const result: Property = new Property(global.generatedEs2panda._UpdateProperty1(global.context, passNode(original), kind, passNode(key), passNode(value), isMethod, isComputed))
+        const result: Property = new Property(global.generatedEs2panda._UpdateProperty1(global.context, passNode(original), kind, passNode(key), passNode(value), isMethod, isComputed), Es2pandaAstNodeType.AST_NODE_TYPE_PROPERTY)
         result.setChildrenParentPtr()
         return result
     }
@@ -90,5 +89,5 @@ export function isProperty(node: object | undefined): node is Property {
     return node instanceof Property
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_PROPERTY)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_PROPERTY, (peer: KNativePointer) => new Property(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_PROPERTY, (peer: KNativePointer) => new Property(peer, Es2pandaAstNodeType.AST_NODE_TYPE_PROPERTY))
 }

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

@@ -37,17 +37,16 @@ import { Es2pandaRegExpFlags } from "./../Es2pandaEnums"
 import { Literal } from "./Literal"
 
 export class RegExpLiteral extends Literal {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 57)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createRegExpLiteral(pattern: string, flags: Es2pandaRegExpFlags, flagsStr: string): RegExpLiteral {
-        const result: RegExpLiteral = new RegExpLiteral(global.generatedEs2panda._CreateRegExpLiteral(global.context, pattern, flags, flagsStr))
+        const result: RegExpLiteral = new RegExpLiteral(global.generatedEs2panda._CreateRegExpLiteral(global.context, pattern, flags, flagsStr), Es2pandaAstNodeType.AST_NODE_TYPE_REGEXP_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
     static updateRegExpLiteral(original: RegExpLiteral | undefined, pattern: string, flags: Es2pandaRegExpFlags, flagsStr: string): RegExpLiteral {
-        const result: RegExpLiteral = new RegExpLiteral(global.generatedEs2panda._UpdateRegExpLiteral(global.context, passNode(original), pattern, flags, flagsStr))
+        const result: RegExpLiteral = new RegExpLiteral(global.generatedEs2panda._UpdateRegExpLiteral(global.context, passNode(original), pattern, flags, flagsStr), Es2pandaAstNodeType.AST_NODE_TYPE_REGEXP_LITERAL)
         result.setChildrenParentPtr()
         return result
     }
@@ -63,5 +62,5 @@ export function isRegExpLiteral(node: object | undefined): node is RegExpLiteral
     return node instanceof RegExpLiteral
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_REGEXP_LITERAL)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_REGEXP_LITERAL, (peer: KNativePointer) => new RegExpLiteral(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_REGEXP_LITERAL, (peer: KNativePointer) => new RegExpLiteral(peer, Es2pandaAstNodeType.AST_NODE_TYPE_REGEXP_LITERAL))
 }

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

@@ -37,22 +37,21 @@ import { Expression } from "./Expression"
 import { Statement } from "./Statement"
 
 export class ReturnStatement extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 59)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static create1ReturnStatement(argument?: Expression): ReturnStatement {
-        const result: ReturnStatement = new ReturnStatement(global.generatedEs2panda._CreateReturnStatement1(global.context, passNode(argument)))
+        const result: ReturnStatement = new ReturnStatement(global.generatedEs2panda._CreateReturnStatement1(global.context, passNode(argument)), Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static updateReturnStatement(original?: ReturnStatement): ReturnStatement {
-        const result: ReturnStatement = new ReturnStatement(global.generatedEs2panda._UpdateReturnStatement(global.context, passNode(original)))
+        const result: ReturnStatement = new ReturnStatement(global.generatedEs2panda._UpdateReturnStatement(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static update1ReturnStatement(original?: ReturnStatement, argument?: Expression): ReturnStatement {
-        const result: ReturnStatement = new ReturnStatement(global.generatedEs2panda._UpdateReturnStatement1(global.context, passNode(original), passNode(argument)))
+        const result: ReturnStatement = new ReturnStatement(global.generatedEs2panda._UpdateReturnStatement1(global.context, passNode(original), passNode(argument)), Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
@@ -73,5 +72,5 @@ export function isReturnStatement(node: object | undefined): node is ReturnState
     return node instanceof ReturnStatement
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT, (peer: KNativePointer) => new ReturnStatement(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT, (peer: KNativePointer) => new ReturnStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT))
 }