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

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -40,19 +39,20 @@ import { Es2pandaModifierFlags } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { Identifier } from "./Identifier"
 import { MethodDefinition } from "./MethodDefinition"
+import { SrcDumper } from "./SrcDumper"
 import { TSClassImplements } from "./TSClassImplements"
 import { TSEnumDeclaration } from "./TSEnumDeclaration"
 import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration"
 import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation"
 import { TypedAstNode } from "./TypedAstNode"
+import { extension_ClassDefinitionSetBody } from "./../../reexport-for-generated"
 
 export class ClassDefinition extends TypedAstNode {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 14)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createClassDefinition(ident: Identifier | undefined, typeParams: TSTypeParameterDeclaration | undefined, superTypeParams: TSTypeParameterInstantiation | undefined, _implements: readonly TSClassImplements[], ctor: MethodDefinition | undefined, superClass: Expression | undefined, body: readonly AstNode[], modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags, annotations?: readonly AnnotationUsage[]): ClassDefinition {
-        const result: ClassDefinition = new ClassDefinition(global.generatedEs2panda._CreateClassDefinition(global.context, passNode(ident), passNode(typeParams), passNode(superTypeParams), passNodeArray(_implements), _implements.length, passNode(ctor), passNode(superClass), passNodeArray(body), body.length, modifiers, flags))
+        const result: ClassDefinition = new ClassDefinition(global.generatedEs2panda._CreateClassDefinition(global.context, passNode(ident), passNode(typeParams), passNode(superTypeParams), passNodeArray(_implements), _implements.length, passNode(ctor), passNode(superClass), passNodeArray(body), body.length, modifiers, flags), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -61,7 +61,7 @@ export class ClassDefinition extends TypedAstNode {
         return result
     }
     static updateClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, typeParams: TSTypeParameterDeclaration | undefined, superTypeParams: TSTypeParameterInstantiation | undefined, _implements: readonly TSClassImplements[], ctor: MethodDefinition | undefined, superClass: Expression | undefined, body: readonly AstNode[], modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags, annotations?: readonly AnnotationUsage[]): ClassDefinition {
-        const result: ClassDefinition = new ClassDefinition(global.generatedEs2panda._UpdateClassDefinition(global.context, passNode(original), passNode(ident), passNode(typeParams), passNode(superTypeParams), passNodeArray(_implements), _implements.length, passNode(ctor), passNode(superClass), passNodeArray(body), body.length, modifiers, flags))
+        const result: ClassDefinition = new ClassDefinition(global.generatedEs2panda._UpdateClassDefinition(global.context, passNode(original), passNode(ident), passNode(typeParams), passNode(superTypeParams), passNodeArray(_implements), _implements.length, passNode(ctor), passNode(superClass), passNodeArray(body), body.length, modifiers, flags), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -70,7 +70,7 @@ export class ClassDefinition extends TypedAstNode {
         return result
     }
     static update1ClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, body: readonly AstNode[], modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags, annotations?: readonly AnnotationUsage[]): ClassDefinition {
-        const result: ClassDefinition = new ClassDefinition(global.generatedEs2panda._UpdateClassDefinition1(global.context, passNode(original), passNode(ident), passNodeArray(body), body.length, modifiers, flags))
+        const result: ClassDefinition = new ClassDefinition(global.generatedEs2panda._UpdateClassDefinition1(global.context, passNode(original), passNode(ident), passNodeArray(body), body.length, modifiers, flags), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -79,7 +79,7 @@ export class ClassDefinition extends TypedAstNode {
         return result
     }
     static update2ClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags, annotations?: readonly AnnotationUsage[]): ClassDefinition {
-        const result: ClassDefinition = new ClassDefinition(global.generatedEs2panda._UpdateClassDefinition2(global.context, passNode(original), passNode(ident), modifiers, flags))
+        const result: ClassDefinition = new ClassDefinition(global.generatedEs2panda._UpdateClassDefinition2(global.context, passNode(original), passNode(ident), modifiers, flags), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -88,7 +88,7 @@ export class ClassDefinition extends TypedAstNode {
         return result
     }
     get ident(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._ClassDefinitionIdent(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ClassDefinitionIdent(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)
     }
     /** @deprecated */
     setIdent(ident?: Identifier): this {
@@ -148,6 +148,9 @@ export class ClassDefinition extends TypedAstNode {
     get isFromStruct(): boolean {
         return global.generatedEs2panda._ClassDefinitionIsFromStructConst(global.context, this.peer)
     }
+    get isInitInCctor(): boolean {
+        return global.generatedEs2panda._ClassDefinitionIsInitInCctorConst(global.context, this.peer)
+    }
     get isModule(): boolean {
         return global.generatedEs2panda._ClassDefinitionIsModuleConst(global.context, this.peer)
     }
@@ -186,6 +189,11 @@ export class ClassDefinition extends TypedAstNode {
         global.generatedEs2panda._ClassDefinitionSetFromStructModifier(global.context, this.peer)
         return this
     }
+    /** @deprecated */
+    setInitInCctor(): this {
+        global.generatedEs2panda._ClassDefinitionSetInitInCctor(global.context, this.peer)
+        return this
+    }
     get modifiers(): Es2pandaClassDefinitionModifiers {
         return global.generatedEs2panda._ClassDefinitionModifiersConst(global.context, this.peer)
     }
@@ -195,13 +203,13 @@ export class ClassDefinition extends TypedAstNode {
         return this
     }
     get ctor(): MethodDefinition | undefined {
-        return unpackNode(global.generatedEs2panda._ClassDefinitionCtor(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ClassDefinitionCtor(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION)
     }
     get typeParams(): TSTypeParameterDeclaration | undefined {
-        return unpackNode(global.generatedEs2panda._ClassDefinitionTypeParams(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ClassDefinitionTypeParams(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION)
     }
     get superTypeParams(): TSTypeParameterInstantiation | undefined {
-        return unpackNode(global.generatedEs2panda._ClassDefinitionSuperTypeParams(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ClassDefinitionSuperTypeParams(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION)
     }
     get localTypeCounter(): number {
         return global.generatedEs2panda._ClassDefinitionLocalTypeCounter(global.context, this.peer)
@@ -210,7 +218,7 @@ export class ClassDefinition extends TypedAstNode {
         return global.generatedEs2panda._ClassDefinitionLocalIndexConst(global.context, this.peer)
     }
     get functionalReferenceReferencedMethod(): MethodDefinition | undefined {
-        return unpackNode(global.generatedEs2panda._ClassDefinitionFunctionalReferenceReferencedMethodConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ClassDefinitionFunctionalReferenceReferencedMethodConst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION)
     }
     /** @deprecated */
     setFunctionalReferenceReferencedMethod(functionalReferenceReferencedMethod?: MethodDefinition): this {
@@ -221,7 +229,7 @@ export class ClassDefinition extends TypedAstNode {
         return unpackString(global.generatedEs2panda._ClassDefinitionLocalPrefixConst(global.context, this.peer))
     }
     get origEnumDecl(): TSEnumDeclaration | undefined {
-        return unpackNode(global.generatedEs2panda._ClassDefinitionOrigEnumDeclConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ClassDefinitionOrigEnumDeclConst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_DECLARATION)
     }
     get anonClass(): ClassDeclaration | undefined {
         return unpackNode(global.generatedEs2panda._ClassDefinitionGetAnonClass(global.context, this.peer))
@@ -282,10 +290,10 @@ export class ClassDefinition extends TypedAstNode {
         return this
     }
     get implements(): readonly TSClassImplements[] {
-        return unpackNodeArray(global.generatedEs2panda._ClassDefinitionImplements(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._ClassDefinitionImplements(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_TS_CLASS_IMPLEMENTS)
     }
     get implementsForUpdate(): readonly TSClassImplements[] {
-        return unpackNodeArray(global.generatedEs2panda._ClassDefinitionImplementsForUpdate(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._ClassDefinitionImplementsForUpdate(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_TS_CLASS_IMPLEMENTS)
     }
     /** @deprecated */
     setCtor(ctor?: MethodDefinition): this {
@@ -312,9 +320,12 @@ export class ClassDefinition extends TypedAstNode {
         global.generatedEs2panda._ClassDefinitionSetInternalName(global.context, this.peer, internalName)
         return this
     }
+    get hasAnnotations(): boolean {
+        return global.generatedEs2panda._ClassDefinitionHasAnnotationsConst(global.context, this.peer)
+    }
     /** @deprecated */
-    emplaceAnnotations(source?: AnnotationUsage): this {
-        global.generatedEs2panda._ClassDefinitionEmplaceAnnotations(global.context, this.peer, passNode(source))
+    emplaceAnnotation(source?: AnnotationUsage): this {
+        global.generatedEs2panda._ClassDefinitionEmplaceAnnotation(global.context, this.peer, passNode(source))
         return this
     }
     /** @deprecated */
@@ -323,15 +334,15 @@ export class ClassDefinition extends TypedAstNode {
         return this
     }
     /** @deprecated */
-    setValueAnnotations(source: AnnotationUsage | undefined, index: number): this {
-        global.generatedEs2panda._ClassDefinitionSetValueAnnotations(global.context, this.peer, passNode(source), index)
+    dumpAnnotations(dumper?: SrcDumper): this {
+        global.generatedEs2panda._ClassDefinitionDumpAnnotationsConst(global.context, this.peer, passNode(dumper))
         return this
     }
     get annotationsForUpdate(): readonly AnnotationUsage[] {
-        return unpackNodeArray(global.generatedEs2panda._ClassDefinitionAnnotationsForUpdate(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._ClassDefinitionAnnotationsForUpdate(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE)
     }
     get annotations(): readonly AnnotationUsage[] {
-        return unpackNodeArray(global.generatedEs2panda._ClassDefinitionAnnotations(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._ClassDefinitionAnnotations(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE)
     }
     /** @deprecated */
     setAnnotations(annotationList: readonly AnnotationUsage[]): this {
@@ -343,16 +354,12 @@ export class ClassDefinition extends TypedAstNode {
         global.generatedEs2panda._ClassDefinitionSetAnnotations1(global.context, this.peer, passNodeArray(annotationList), annotationList.length)
         return this
     }
-    /** @deprecated */
-    addAnnotations(annotations?: AnnotationUsage): this {
-        global.generatedEs2panda._ClassDefinitionAddAnnotations(global.context, this.peer, passNode(annotations))
-        return this
-    }
+    setBody = extension_ClassDefinitionSetBody
     protected readonly brandClassDefinition: undefined
 }
 export function isClassDefinition(node: object | undefined): node is ClassDefinition {
     return node instanceof ClassDefinition
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION, (peer: KNativePointer) => new ClassDefinition(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION, (peer: KNativePointer) => new ClassDefinition(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -32,18 +31,18 @@ import {
     unpackString
 } from "../../reexport-for-generated"
 
-import { Decorator } from "./Decorator"
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { Identifier } from "./Identifier"
 import { TSEnumMember } from "./TSEnumMember"
 import { TypedStatement } from "./TypedStatement"
 
 export class ClassElement extends TypedStatement {
-    constructor(pointer: KNativePointer) {
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     get id(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._ClassElementId(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ClassElementId(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)
     }
     get key(): Expression | undefined {
         return unpackNode(global.generatedEs2panda._ClassElementKey(global.context, this.peer))
@@ -57,7 +56,7 @@ export class ClassElement extends TypedStatement {
         return this
     }
     get originEnumMember(): TSEnumMember | undefined {
-        return unpackNode(global.generatedEs2panda._ClassElementOriginEnumMemberConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ClassElementOriginEnumMemberConst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_MEMBER)
     }
     /** @deprecated */
     setOrigEnumMember(enumMember?: TSEnumMember): this {
@@ -70,32 +69,6 @@ export class ClassElement extends TypedStatement {
     get isComputed(): boolean {
         return global.generatedEs2panda._ClassElementIsComputedConst(global.context, this.peer)
     }
-    /** @deprecated */
-    addDecorator(decorator?: Decorator): this {
-        global.generatedEs2panda._ClassElementAddDecorator(global.context, this.peer, passNode(decorator))
-        return this
-    }
-    /** @deprecated */
-    emplaceDecorators(decorators?: Decorator): this {
-        global.generatedEs2panda._ClassElementEmplaceDecorators(global.context, this.peer, passNode(decorators))
-        return this
-    }
-    /** @deprecated */
-    clearDecorators(): this {
-        global.generatedEs2panda._ClassElementClearDecorators(global.context, this.peer)
-        return this
-    }
-    /** @deprecated */
-    setValueDecorators(decorators: Decorator | undefined, index: number): this {
-        global.generatedEs2panda._ClassElementSetValueDecorators(global.context, this.peer, passNode(decorators), index)
-        return this
-    }
-    get decorators(): readonly Decorator[] {
-        return unpackNodeArray(global.generatedEs2panda._ClassElementDecorators(global.context, this.peer))
-    }
-    get decoratorsForUpdate(): readonly Decorator[] {
-        return unpackNodeArray(global.generatedEs2panda._ClassElementDecoratorsForUpdate(global.context, this.peer))
-    }
     protected readonly brandClassElement: undefined
 }
 export function isClassElement(node: object | undefined): node is ClassElement {

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,22 +36,21 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 
 export class ClassExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 16)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createClassExpression(def?: ClassDefinition): ClassExpression {
-        const result: ClassExpression = new ClassExpression(global.generatedEs2panda._CreateClassExpression(global.context, passNode(def)))
+        const result: ClassExpression = new ClassExpression(global.generatedEs2panda._CreateClassExpression(global.context, passNode(def)), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateClassExpression(original?: ClassExpression, def?: ClassDefinition): ClassExpression {
-        const result: ClassExpression = new ClassExpression(global.generatedEs2panda._UpdateClassExpression(global.context, passNode(original), passNode(def)))
+        const result: ClassExpression = new ClassExpression(global.generatedEs2panda._UpdateClassExpression(global.context, passNode(original), passNode(def)), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     get definition(): ClassDefinition | undefined {
-        return unpackNode(global.generatedEs2panda._ClassExpressionDefinitionConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ClassExpressionDefinitionConst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION)
     }
     protected readonly brandClassExpression: undefined
 }
@@ -60,5 +58,5 @@ export function isClassExpression(node: object | undefined): node is ClassExpres
     return node instanceof ClassExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_EXPRESSION, (peer: KNativePointer) => new ClassExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_EXPRESSION, (peer: KNativePointer) => new ClassExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_EXPRESSION))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,15 +36,15 @@ import { ClassElement } from "./ClassElement"
 import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Es2pandaModifierFlags } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
+import { SrcDumper } from "./SrcDumper"
 import { TypeNode } from "./TypeNode"
 
 export class ClassProperty extends ClassElement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 17)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createClassProperty(key: Expression | undefined, value: Expression | undefined, typeAnnotation: TypeNode | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean, annotations?: readonly AnnotationUsage[]): ClassProperty {
-        const result: ClassProperty = new ClassProperty(global.generatedEs2panda._CreateClassProperty(global.context, passNode(key), passNode(value), passNode(typeAnnotation), modifiers, isComputed))
+        const result: ClassProperty = new ClassProperty(global.generatedEs2panda._CreateClassProperty(global.context, passNode(key), passNode(value), passNode(typeAnnotation), modifiers, isComputed), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -54,7 +53,7 @@ export class ClassProperty extends ClassElement {
         return result
     }
     static updateClassProperty(original: ClassProperty | undefined, key: Expression | undefined, value: Expression | undefined, typeAnnotation: TypeNode | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean, annotations?: readonly AnnotationUsage[]): ClassProperty {
-        const result: ClassProperty = new ClassProperty(global.generatedEs2panda._UpdateClassProperty(global.context, passNode(original), passNode(key), passNode(value), passNode(typeAnnotation), modifiers, isComputed))
+        const result: ClassProperty = new ClassProperty(global.generatedEs2panda._UpdateClassProperty(global.context, passNode(original), passNode(key), passNode(value), passNode(typeAnnotation), modifiers, isComputed), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -82,13 +81,24 @@ export class ClassProperty extends ClassElement {
         return global.generatedEs2panda._ClassPropertyNeedInitInStaticBlockConst(global.context, this.peer)
     }
     /** @deprecated */
-    setInitInStaticBlock(needInitInStaticBlock: boolean): this {
-        global.generatedEs2panda._ClassPropertySetInitInStaticBlock(global.context, this.peer, needInitInStaticBlock)
+    setNeedInitInStaticBlock(): this {
+        global.generatedEs2panda._ClassPropertySetNeedInitInStaticBlock(global.context, this.peer)
         return this
     }
+    get isImmediateInit(): boolean {
+        return global.generatedEs2panda._ClassPropertyIsImmediateInitConst(global.context, this.peer)
+    }
+    /** @deprecated */
+    setIsImmediateInit(): this {
+        global.generatedEs2panda._ClassPropertySetIsImmediateInit(global.context, this.peer)
+        return this
+    }
+    get hasAnnotations(): boolean {
+        return global.generatedEs2panda._ClassPropertyHasAnnotationsConst(global.context, this.peer)
+    }
     /** @deprecated */
-    emplaceAnnotations(source?: AnnotationUsage): this {
-        global.generatedEs2panda._ClassPropertyEmplaceAnnotations(global.context, this.peer, passNode(source))
+    emplaceAnnotation(source?: AnnotationUsage): this {
+        global.generatedEs2panda._ClassPropertyEmplaceAnnotation(global.context, this.peer, passNode(source))
         return this
     }
     /** @deprecated */
@@ -97,15 +107,15 @@ export class ClassProperty extends ClassElement {
         return this
     }
     /** @deprecated */
-    setValueAnnotations(source: AnnotationUsage | undefined, index: number): this {
-        global.generatedEs2panda._ClassPropertySetValueAnnotations(global.context, this.peer, passNode(source), index)
+    dumpAnnotations(dumper?: SrcDumper): this {
+        global.generatedEs2panda._ClassPropertyDumpAnnotationsConst(global.context, this.peer, passNode(dumper))
         return this
     }
     get annotationsForUpdate(): readonly AnnotationUsage[] {
-        return unpackNodeArray(global.generatedEs2panda._ClassPropertyAnnotationsForUpdate(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._ClassPropertyAnnotationsForUpdate(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE)
     }
     get annotations(): readonly AnnotationUsage[] {
-        return unpackNodeArray(global.generatedEs2panda._ClassPropertyAnnotations(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._ClassPropertyAnnotations(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE)
     }
     /** @deprecated */
     setAnnotations(annotationList: readonly AnnotationUsage[]): this {
@@ -117,16 +127,11 @@ export class ClassProperty extends ClassElement {
         global.generatedEs2panda._ClassPropertySetAnnotations1(global.context, this.peer, passNodeArray(annotationList), annotationList.length)
         return this
     }
-    /** @deprecated */
-    addAnnotations(annotations?: AnnotationUsage): this {
-        global.generatedEs2panda._ClassPropertyAddAnnotations(global.context, this.peer, passNode(annotations))
-        return this
-    }
     protected readonly brandClassProperty: undefined
 }
 export function isClassProperty(node: object | undefined): node is ClassProperty {
     return node instanceof ClassProperty
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY, (peer: KNativePointer) => new ClassProperty(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY, (peer: KNativePointer) => new ClassProperty(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -38,22 +37,21 @@ import { Expression } from "./Expression"
 import { ScriptFunction } from "./ScriptFunction"
 
 export class ClassStaticBlock extends ClassElement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 18)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createClassStaticBlock(value?: Expression): ClassStaticBlock {
-        const result: ClassStaticBlock = new ClassStaticBlock(global.generatedEs2panda._CreateClassStaticBlock(global.context, passNode(value)))
+        const result: ClassStaticBlock = new ClassStaticBlock(global.generatedEs2panda._CreateClassStaticBlock(global.context, passNode(value)), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK)
         result.setChildrenParentPtr()
         return result
     }
     static updateClassStaticBlock(original?: ClassStaticBlock, value?: Expression): ClassStaticBlock {
-        const result: ClassStaticBlock = new ClassStaticBlock(global.generatedEs2panda._UpdateClassStaticBlock(global.context, passNode(original), passNode(value)))
+        const result: ClassStaticBlock = new ClassStaticBlock(global.generatedEs2panda._UpdateClassStaticBlock(global.context, passNode(original), passNode(value)), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK)
         result.setChildrenParentPtr()
         return result
     }
     get function(): ScriptFunction | undefined {
-        return unpackNode(global.generatedEs2panda._ClassStaticBlockFunction(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ClassStaticBlockFunction(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION)
     }
     get name(): string {
         return unpackString(global.generatedEs2panda._ClassStaticBlockNameConst(global.context, this.peer))
@@ -64,5 +62,5 @@ export function isClassStaticBlock(node: object | undefined): node is ClassStati
     return node instanceof ClassStaticBlock
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK, (peer: KNativePointer) => new ClassStaticBlock(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK, (peer: KNativePointer) => new ClassStaticBlock(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK))
 }

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

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

package/build/libarkts-copy/src/generated/peers/ConditionalExpression.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 ConditionalExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 19)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createConditionalExpression(test?: Expression, consequent?: Expression, alternate?: Expression): ConditionalExpression {
-        const result: ConditionalExpression = new ConditionalExpression(global.generatedEs2panda._CreateConditionalExpression(global.context, passNode(test), passNode(consequent), passNode(alternate)))
+        const result: ConditionalExpression = new ConditionalExpression(global.generatedEs2panda._CreateConditionalExpression(global.context, passNode(test), passNode(consequent), passNode(alternate)), Es2pandaAstNodeType.AST_NODE_TYPE_CONDITIONAL_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateConditionalExpression(original?: ConditionalExpression, test?: Expression, consequent?: Expression, alternate?: Expression): ConditionalExpression {
-        const result: ConditionalExpression = new ConditionalExpression(global.generatedEs2panda._UpdateConditionalExpression(global.context, passNode(original), passNode(test), passNode(consequent), passNode(alternate)))
+        const result: ConditionalExpression = new ConditionalExpression(global.generatedEs2panda._UpdateConditionalExpression(global.context, passNode(original), passNode(test), passNode(consequent), passNode(alternate)), Es2pandaAstNodeType.AST_NODE_TYPE_CONDITIONAL_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -80,5 +78,5 @@ export function isConditionalExpression(node: object | undefined): node is Condi
     return node instanceof ConditionalExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CONDITIONAL_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CONDITIONAL_EXPRESSION, (peer: KNativePointer) => new ConditionalExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CONDITIONAL_EXPRESSION, (peer: KNativePointer) => new ConditionalExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CONDITIONAL_EXPRESSION))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -37,27 +36,26 @@ import { Identifier } from "./Identifier"
 import { Statement } from "./Statement"
 
 export class ContinueStatement extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 20)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static create1ContinueStatement(ident?: Identifier): ContinueStatement {
-        const result: ContinueStatement = new ContinueStatement(global.generatedEs2panda._CreateContinueStatement1(global.context, passNode(ident)))
+        const result: ContinueStatement = new ContinueStatement(global.generatedEs2panda._CreateContinueStatement1(global.context, passNode(ident)), Es2pandaAstNodeType.AST_NODE_TYPE_CONTINUE_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static updateContinueStatement(original?: ContinueStatement): ContinueStatement {
-        const result: ContinueStatement = new ContinueStatement(global.generatedEs2panda._UpdateContinueStatement(global.context, passNode(original)))
+        const result: ContinueStatement = new ContinueStatement(global.generatedEs2panda._UpdateContinueStatement(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_CONTINUE_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static update1ContinueStatement(original?: ContinueStatement, ident?: Identifier): ContinueStatement {
-        const result: ContinueStatement = new ContinueStatement(global.generatedEs2panda._UpdateContinueStatement1(global.context, passNode(original), passNode(ident)))
+        const result: ContinueStatement = new ContinueStatement(global.generatedEs2panda._UpdateContinueStatement1(global.context, passNode(original), passNode(ident)), Es2pandaAstNodeType.AST_NODE_TYPE_CONTINUE_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     get ident(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._ContinueStatementIdent(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ContinueStatementIdent(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)
     }
     get target(): AstNode | undefined {
         return unpackNode(global.generatedEs2panda._ContinueStatementTargetConst(global.context, this.peer))
@@ -76,5 +74,5 @@ export function isContinueStatement(node: object | undefined): node is ContinueS
     return node instanceof ContinueStatement
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CONTINUE_STATEMENT)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CONTINUE_STATEMENT, (peer: KNativePointer) => new ContinueStatement(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CONTINUE_STATEMENT, (peer: KNativePointer) => new ContinueStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CONTINUE_STATEMENT))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -36,17 +35,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Statement } from "./Statement"
 
 export class DebuggerStatement extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 21)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createDebuggerStatement(): DebuggerStatement {
-        const result: DebuggerStatement = new DebuggerStatement(global.generatedEs2panda._CreateDebuggerStatement(global.context))
+        const result: DebuggerStatement = new DebuggerStatement(global.generatedEs2panda._CreateDebuggerStatement(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_DEBUGGER_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
     static updateDebuggerStatement(original?: DebuggerStatement): DebuggerStatement {
-        const result: DebuggerStatement = new DebuggerStatement(global.generatedEs2panda._UpdateDebuggerStatement(global.context, passNode(original)))
+        const result: DebuggerStatement = new DebuggerStatement(global.generatedEs2panda._UpdateDebuggerStatement(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_DEBUGGER_STATEMENT)
         result.setChildrenParentPtr()
         return result
     }
@@ -56,5 +54,5 @@ export function isDebuggerStatement(node: object | undefined): node is DebuggerS
     return node instanceof DebuggerStatement
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_DEBUGGER_STATEMENT)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_DEBUGGER_STATEMENT, (peer: KNativePointer) => new DebuggerStatement(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_DEBUGGER_STATEMENT, (peer: KNativePointer) => new DebuggerStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_DEBUGGER_STATEMENT))
 }

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

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

package/build/libarkts-copy/src/generated/peers/Decorator.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 Decorator extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 22)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createDecorator(expr?: Expression): Decorator {
-        const result: Decorator = new Decorator(global.generatedEs2panda._CreateDecorator(global.context, passNode(expr)))
+        const result: Decorator = new Decorator(global.generatedEs2panda._CreateDecorator(global.context, passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_DECORATOR)
         result.setChildrenParentPtr()
         return result
     }
     static updateDecorator(original?: Decorator, expr?: Expression): Decorator {
-        const result: Decorator = new Decorator(global.generatedEs2panda._UpdateDecorator(global.context, passNode(original), passNode(expr)))
+        const result: Decorator = new Decorator(global.generatedEs2panda._UpdateDecorator(global.context, passNode(original), passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_DECORATOR)
         result.setChildrenParentPtr()
         return result
     }
@@ -60,5 +58,5 @@ export function isDecorator(node: object | undefined): node is Decorator {
     return node instanceof Decorator
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_DECORATOR)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_DECORATOR, (peer: KNativePointer) => new Decorator(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_DECORATOR, (peer: KNativePointer) => new Decorator(peer, Es2pandaAstNodeType.AST_NODE_TYPE_DECORATOR))
 }

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

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