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

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -1208,11 +1207,11 @@ export const factory = {
         return updateNodeByNode(SequenceExpression.createSequenceExpression(sequence), original)
     }
     ,
-    createArrowFunctionExpression(_function?: ScriptFunction, annotations?: readonly AnnotationUsage[]): ArrowFunctionExpression {
+    createArrowFunctionExpression(_function: ScriptFunction, annotations?: readonly AnnotationUsage[]): ArrowFunctionExpression {
         return ArrowFunctionExpression.createArrowFunctionExpression(_function, annotations)
     }
     ,
-    updateArrowFunctionExpression(original: ArrowFunctionExpression, _function?: ScriptFunction, annotations?: readonly AnnotationUsage[]): ArrowFunctionExpression {
+    updateArrowFunctionExpression(original: ArrowFunctionExpression, _function: ScriptFunction, annotations?: readonly AnnotationUsage[]): ArrowFunctionExpression {
         if (isSameNativeObject(_function, original.function) && isSameNativeObject(annotations, original.annotations))
             return original
         return updateNodeByNode(ArrowFunctionExpression.createArrowFunctionExpression(_function, annotations), original)

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

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

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

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

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

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

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

@@ -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 AnnotatedStatement extends Statement {
-    constructor(pointer: KNativePointer) {
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     protected readonly brandAnnotatedStatement: undefined
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -36,25 +35,25 @@ import { AnnotationUsage } from "./AnnotationUsage"
 import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { Identifier } from "./Identifier"
+import { SrcDumper } from "./SrcDumper"
 import { Statement } from "./Statement"
 
 export class AnnotationDeclaration extends Statement {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 1)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static create1AnnotationDeclaration(expr: Expression | undefined, properties: readonly AstNode[]): AnnotationDeclaration {
-        const result: AnnotationDeclaration = new AnnotationDeclaration(global.generatedEs2panda._CreateAnnotationDeclaration1(global.context, passNode(expr), passNodeArray(properties), properties.length))
+        const result: AnnotationDeclaration = new AnnotationDeclaration(global.generatedEs2panda._CreateAnnotationDeclaration1(global.context, passNode(expr), passNodeArray(properties), properties.length), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     static updateAnnotationDeclaration(original?: AnnotationDeclaration, expr?: Expression): AnnotationDeclaration {
-        const result: AnnotationDeclaration = new AnnotationDeclaration(global.generatedEs2panda._UpdateAnnotationDeclaration(global.context, passNode(original), passNode(expr)))
+        const result: AnnotationDeclaration = new AnnotationDeclaration(global.generatedEs2panda._UpdateAnnotationDeclaration(global.context, passNode(original), passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
     static update1AnnotationDeclaration(original: AnnotationDeclaration | undefined, expr: Expression | undefined, properties: readonly AstNode[]): AnnotationDeclaration {
-        const result: AnnotationDeclaration = new AnnotationDeclaration(global.generatedEs2panda._UpdateAnnotationDeclaration1(global.context, passNode(original), passNode(expr), passNodeArray(properties), properties.length))
+        const result: AnnotationDeclaration = new AnnotationDeclaration(global.generatedEs2panda._UpdateAnnotationDeclaration1(global.context, passNode(original), passNode(expr), passNodeArray(properties), properties.length), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_DECLARATION)
         result.setChildrenParentPtr()
         return result
     }
@@ -105,7 +104,7 @@ export class AnnotationDeclaration extends Statement {
         return this
     }
     get baseName(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._AnnotationDeclarationGetBaseNameConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._AnnotationDeclarationGetBaseNameConst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)
     }
     /** @deprecated */
     emplaceProperties(properties?: AstNode): this {
@@ -122,9 +121,12 @@ export class AnnotationDeclaration extends Statement {
         global.generatedEs2panda._AnnotationDeclarationSetValueProperties(global.context, this.peer, passNode(properties), index)
         return this
     }
+    get hasAnnotations(): boolean {
+        return global.generatedEs2panda._AnnotationDeclarationHasAnnotationsConst(global.context, this.peer)
+    }
     /** @deprecated */
-    emplaceAnnotations(source?: AnnotationUsage): this {
-        global.generatedEs2panda._AnnotationDeclarationEmplaceAnnotations(global.context, this.peer, passNode(source))
+    emplaceAnnotation(source?: AnnotationUsage): this {
+        global.generatedEs2panda._AnnotationDeclarationEmplaceAnnotation(global.context, this.peer, passNode(source))
         return this
     }
     /** @deprecated */
@@ -133,15 +135,15 @@ export class AnnotationDeclaration extends Statement {
         return this
     }
     /** @deprecated */
-    setValueAnnotations(source: AnnotationUsage | undefined, index: number): this {
-        global.generatedEs2panda._AnnotationDeclarationSetValueAnnotations(global.context, this.peer, passNode(source), index)
+    dumpAnnotations(dumper?: SrcDumper): this {
+        global.generatedEs2panda._AnnotationDeclarationDumpAnnotationsConst(global.context, this.peer, passNode(dumper))
         return this
     }
     get annotationsForUpdate(): readonly AnnotationUsage[] {
-        return unpackNodeArray(global.generatedEs2panda._AnnotationDeclarationAnnotationsForUpdate(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._AnnotationDeclarationAnnotationsForUpdate(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE)
     }
     get annotations(): readonly AnnotationUsage[] {
-        return unpackNodeArray(global.generatedEs2panda._AnnotationDeclarationAnnotations(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._AnnotationDeclarationAnnotations(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE)
     }
     /** @deprecated */
     setAnnotations(annotationList: readonly AnnotationUsage[]): this {
@@ -153,16 +155,11 @@ export class AnnotationDeclaration extends Statement {
         global.generatedEs2panda._AnnotationDeclarationSetAnnotations1(global.context, this.peer, passNodeArray(annotationList), annotationList.length)
         return this
     }
-    /** @deprecated */
-    addAnnotations(annotations?: AnnotationUsage): this {
-        global.generatedEs2panda._AnnotationDeclarationAddAnnotations(global.context, this.peer, passNode(annotations))
-        return this
-    }
     protected readonly brandAnnotationDeclaration: undefined
 }
 export function isAnnotationDeclaration(node: object | undefined): node is AnnotationDeclaration {
     return node instanceof AnnotationDeclaration
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_DECLARATION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_DECLARATION, (peer: KNativePointer) => new AnnotationDeclaration(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_DECLARATION, (peer: KNativePointer) => new AnnotationDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_DECLARATION))
 }

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

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

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

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

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -33,29 +32,27 @@ import {
 } from "../../reexport-for-generated"
 
 import { AnnotatedExpression } from "./AnnotatedExpression"
-import { Decorator } from "./Decorator"
 import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { TypeNode } from "./TypeNode"
 import { ValidationInfo } from "./ValidationInfo"
 
 export class ArrayExpression extends AnnotatedExpression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 159)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static create1ArrayExpression(nodeType: Es2pandaAstNodeType, elements: readonly Expression[], trailingComma: boolean): ArrayExpression {
-        const result: ArrayExpression = new ArrayExpression(global.generatedEs2panda._CreateArrayExpression1(global.context, nodeType, passNodeArray(elements), elements.length, trailingComma))
+        const result: ArrayExpression = new ArrayExpression(global.generatedEs2panda._CreateArrayExpression1(global.context, nodeType, passNodeArray(elements), elements.length, trailingComma), Es2pandaAstNodeType.AST_NODE_TYPE_ARRAY_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateArrayExpression(original: ArrayExpression | undefined, elements: readonly Expression[]): ArrayExpression {
-        const result: ArrayExpression = new ArrayExpression(global.generatedEs2panda._UpdateArrayExpression(global.context, passNode(original), passNodeArray(elements), elements.length))
+        const result: ArrayExpression = new ArrayExpression(global.generatedEs2panda._UpdateArrayExpression(global.context, passNode(original), passNodeArray(elements), elements.length), Es2pandaAstNodeType.AST_NODE_TYPE_ARRAY_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static update1ArrayExpression(original: ArrayExpression | undefined, nodeType: Es2pandaAstNodeType, elements: readonly Expression[], trailingComma: boolean): ArrayExpression {
-        const result: ArrayExpression = new ArrayExpression(global.generatedEs2panda._UpdateArrayExpression1(global.context, passNode(original), nodeType, passNodeArray(elements), elements.length, trailingComma))
+        const result: ArrayExpression = new ArrayExpression(global.generatedEs2panda._UpdateArrayExpression1(global.context, passNode(original), nodeType, passNodeArray(elements), elements.length, trailingComma), Es2pandaAstNodeType.AST_NODE_TYPE_ARRAY_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -83,9 +80,6 @@ export class ArrayExpression extends AnnotatedExpression {
         global.generatedEs2panda._ArrayExpressionSetOptional(global.context, this.peer, optional_arg)
         return this
     }
-    get decorators(): readonly Decorator[] {
-        return unpackNodeArray(global.generatedEs2panda._ArrayExpressionDecoratorsConst(global.context, this.peer))
-    }
     /** @deprecated */
     clearPreferredType(): this {
         global.generatedEs2panda._ArrayExpressionClearPreferredType(global.context, this.peer)
@@ -111,5 +105,5 @@ export function isArrayExpression(node: object | undefined): node is ArrayExpres
     return node instanceof ArrayExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ARRAY_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ARRAY_EXPRESSION, (peer: KNativePointer) => new ArrayExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ARRAY_EXPRESSION, (peer: KNativePointer) => new ArrayExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ARRAY_EXPRESSION))
 }

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -36,15 +35,15 @@ import { AnnotationUsage } from "./AnnotationUsage"
 import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { ScriptFunction } from "./ScriptFunction"
+import { SrcDumper } from "./SrcDumper"
 import { TypeNode } from "./TypeNode"
 
 export class ArrowFunctionExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 0)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createArrowFunctionExpression(func?: ScriptFunction, annotations?: readonly AnnotationUsage[]): ArrowFunctionExpression {
-        const result: ArrowFunctionExpression = new ArrowFunctionExpression(global.generatedEs2panda._CreateArrowFunctionExpression(global.context, passNode(func)))
+        const result: ArrowFunctionExpression = new ArrowFunctionExpression(global.generatedEs2panda._CreateArrowFunctionExpression(global.context, passNode(func)), Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -53,7 +52,7 @@ export class ArrowFunctionExpression extends Expression {
         return result
     }
     static updateArrowFunctionExpression(original?: ArrowFunctionExpression, func?: ScriptFunction, annotations?: readonly AnnotationUsage[]): ArrowFunctionExpression {
-        const result: ArrowFunctionExpression = new ArrowFunctionExpression(global.generatedEs2panda._UpdateArrowFunctionExpression(global.context, passNode(original), passNode(func)))
+        const result: ArrowFunctionExpression = new ArrowFunctionExpression(global.generatedEs2panda._UpdateArrowFunctionExpression(global.context, passNode(original), passNode(func)), Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -62,7 +61,7 @@ export class ArrowFunctionExpression extends Expression {
         return result
     }
     static update1ArrowFunctionExpression(original?: ArrowFunctionExpression, other?: ArrowFunctionExpression, annotations?: readonly AnnotationUsage[]): ArrowFunctionExpression {
-        const result: ArrowFunctionExpression = new ArrowFunctionExpression(global.generatedEs2panda._UpdateArrowFunctionExpression1(global.context, passNode(original), passNode(other)))
+        const result: ArrowFunctionExpression = new ArrowFunctionExpression(global.generatedEs2panda._UpdateArrowFunctionExpression1(global.context, passNode(original), passNode(other)), Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION)
         if (annotations)
         {
             result.setAnnotations(annotations)
@@ -70,15 +69,18 @@ export class ArrowFunctionExpression extends Expression {
         result.setChildrenParentPtr()
         return result
     }
-    get function(): ScriptFunction | undefined {
-        return unpackNode(global.generatedEs2panda._ArrowFunctionExpressionFunction(global.context, this.peer))
+    get function(): ScriptFunction {
+        return unpackNonNullableNode(global.generatedEs2panda._ArrowFunctionExpressionFunction(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION)
     }
     get createTypeAnnotation(): TypeNode | undefined {
         return unpackNode(global.generatedEs2panda._ArrowFunctionExpressionCreateTypeAnnotation(global.context, this.peer))
     }
+    get hasAnnotations(): boolean {
+        return global.generatedEs2panda._ArrowFunctionExpressionHasAnnotationsConst(global.context, this.peer)
+    }
     /** @deprecated */
-    emplaceAnnotations(source?: AnnotationUsage): this {
-        global.generatedEs2panda._ArrowFunctionExpressionEmplaceAnnotations(global.context, this.peer, passNode(source))
+    emplaceAnnotation(source?: AnnotationUsage): this {
+        global.generatedEs2panda._ArrowFunctionExpressionEmplaceAnnotation(global.context, this.peer, passNode(source))
         return this
     }
     /** @deprecated */
@@ -87,15 +89,15 @@ export class ArrowFunctionExpression extends Expression {
         return this
     }
     /** @deprecated */
-    setValueAnnotations(source: AnnotationUsage | undefined, index: number): this {
-        global.generatedEs2panda._ArrowFunctionExpressionSetValueAnnotations(global.context, this.peer, passNode(source), index)
+    dumpAnnotations(dumper?: SrcDumper): this {
+        global.generatedEs2panda._ArrowFunctionExpressionDumpAnnotationsConst(global.context, this.peer, passNode(dumper))
         return this
     }
     get annotationsForUpdate(): readonly AnnotationUsage[] {
-        return unpackNodeArray(global.generatedEs2panda._ArrowFunctionExpressionAnnotationsForUpdate(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._ArrowFunctionExpressionAnnotationsForUpdate(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE)
     }
     get annotations(): readonly AnnotationUsage[] {
-        return unpackNodeArray(global.generatedEs2panda._ArrowFunctionExpressionAnnotations(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._ArrowFunctionExpressionAnnotations(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE)
     }
     /** @deprecated */
     setAnnotations(annotationList: readonly AnnotationUsage[]): this {
@@ -107,16 +109,11 @@ export class ArrowFunctionExpression extends Expression {
         global.generatedEs2panda._ArrowFunctionExpressionSetAnnotations1(global.context, this.peer, passNodeArray(annotationList), annotationList.length)
         return this
     }
-    /** @deprecated */
-    addAnnotations(annotations?: AnnotationUsage): this {
-        global.generatedEs2panda._ArrowFunctionExpressionAddAnnotations(global.context, this.peer, passNode(annotations))
-        return this
-    }
     protected readonly brandArrowFunctionExpression: undefined
 }
 export function isArrowFunctionExpression(node: object | undefined): node is ArrowFunctionExpression {
     return node instanceof ArrowFunctionExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION, (peer: KNativePointer) => new ArrowFunctionExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION, (peer: KNativePointer) => new ArrowFunctionExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION))
 }

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

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

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

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

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

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -45,3 +44,6 @@ export class AstDumper extends ArktsObject {
     }
     protected readonly brandAstDumper: undefined
 }
+export function isAstDumper(node: object | undefined): node is AstDumper {
+    return node instanceof AstDumper
+}

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

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

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

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

package/build/libarkts-copy/src/generated/peers/AwaitExpression.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 AwaitExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 4)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createAwaitExpression(argument?: Expression): AwaitExpression {
-        const result: AwaitExpression = new AwaitExpression(global.generatedEs2panda._CreateAwaitExpression(global.context, passNode(argument)))
+        const result: AwaitExpression = new AwaitExpression(global.generatedEs2panda._CreateAwaitExpression(global.context, passNode(argument)), Es2pandaAstNodeType.AST_NODE_TYPE_AWAIT_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateAwaitExpression(original?: AwaitExpression, argument?: Expression): AwaitExpression {
-        const result: AwaitExpression = new AwaitExpression(global.generatedEs2panda._UpdateAwaitExpression(global.context, passNode(original), passNode(argument)))
+        const result: AwaitExpression = new AwaitExpression(global.generatedEs2panda._UpdateAwaitExpression(global.context, passNode(original), passNode(argument)), Es2pandaAstNodeType.AST_NODE_TYPE_AWAIT_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -59,5 +57,5 @@ export function isAwaitExpression(node: object | undefined): node is AwaitExpres
     return node instanceof AwaitExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_AWAIT_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_AWAIT_EXPRESSION, (peer: KNativePointer) => new AwaitExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_AWAIT_EXPRESSION, (peer: KNativePointer) => new AwaitExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_AWAIT_EXPRESSION))
 }