@idlizer/arktscgen 2.1.2 → 2.1.7

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

@@ -22,16 +22,16 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 export class TSArrayType extends TypeNode {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 101)
         super(pointer)
     }
@@ -48,6 +48,6 @@ export class TSArrayType extends TypeNode {
 export function isTSArrayType(node: object | undefined): node is TSArrayType {
     return node instanceof TSArrayType
 }
-if (!nodeByType.has(101)) {
-    nodeByType.set(101, TSArrayType)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_ARRAY_TYPE)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_ARRAY_TYPE, (peer: KNativePointer) => new TSArrayType(peer))
 }

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -30,10 +29,11 @@ import {
 } from "../../reexport-for-generated"
 
 import { AnnotatedExpression } from "./AnnotatedExpression"
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { TypeNode } from "./TypeNode"
 export class TSAsExpression extends AnnotatedExpression {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 137)
         super(pointer)
     }
@@ -44,7 +44,7 @@ export class TSAsExpression extends AnnotatedExpression {
         return new TSAsExpression(global.generatedEs2panda._UpdateTSAsExpression(global.context, passNode(original), passNode(expression), passNode(typeAnnotation), isConst))
     }
     get expr(): Expression | undefined {
-        return unpackNode(global.generatedEs2panda._TSAsExpressionExprConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSAsExpressionExpr(global.context, this.peer))
     }
     /** @deprecated */
     setExpr(expr?: Expression): this {
@@ -71,6 +71,6 @@ export class TSAsExpression extends AnnotatedExpression {
 export function isTSAsExpression(node: object | undefined): node is TSAsExpression {
     return node instanceof TSAsExpression
 }
-if (!nodeByType.has(137)) {
-    nodeByType.set(137, TSAsExpression)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_AS_EXPRESSION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_AS_EXPRESSION, (peer: KNativePointer) => new TSAsExpression(peer))
 }

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

@@ -22,16 +22,16 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 export class TSBigintKeyword extends TypeNode {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 97)
         super(pointer)
     }
@@ -45,6 +45,6 @@ export class TSBigintKeyword extends TypeNode {
 export function isTSBigintKeyword(node: object | undefined): node is TSBigintKeyword {
     return node instanceof TSBigintKeyword
 }
-if (!nodeByType.has(97)) {
-    nodeByType.set(97, TSBigintKeyword)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_BIGINT_KEYWORD)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_BIGINT_KEYWORD, (peer: KNativePointer) => new TSBigintKeyword(peer))
 }

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

@@ -22,16 +22,16 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 export class TSBooleanKeyword extends TypeNode {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 92)
         super(pointer)
     }
@@ -45,6 +45,6 @@ export class TSBooleanKeyword extends TypeNode {
 export function isTSBooleanKeyword(node: object | undefined): node is TSBooleanKeyword {
     return node instanceof TSBooleanKeyword
 }
-if (!nodeByType.has(92)) {
-    nodeByType.set(92, TSBooleanKeyword)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_BOOLEAN_KEYWORD)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_BOOLEAN_KEYWORD, (peer: KNativePointer) => new TSBooleanKeyword(peer))
 }

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

@@ -22,17 +22,17 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation"
 export class TSClassImplements extends Expression {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 138)
         super(pointer)
     }
@@ -46,7 +46,7 @@ export class TSClassImplements extends Expression {
         return new TSClassImplements(global.generatedEs2panda._UpdateTSClassImplements1(global.context, passNode(original), passNode(expression)))
     }
     get expr(): Expression | undefined {
-        return unpackNode(global.generatedEs2panda._TSClassImplementsExprConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSClassImplementsExpr(global.context, this.peer))
     }
     get typeParameters(): TSTypeParameterInstantiation | undefined {
         return unpackNode(global.generatedEs2panda._TSClassImplementsTypeParametersConst(global.context, this.peer))
@@ -55,6 +55,6 @@ export class TSClassImplements extends Expression {
 export function isTSClassImplements(node: object | undefined): node is TSClassImplements {
     return node instanceof TSClassImplements
 }
-if (!nodeByType.has(138)) {
-    nodeByType.set(138, TSClassImplements)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_CLASS_IMPLEMENTS)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_CLASS_IMPLEMENTS, (peer: KNativePointer) => new TSClassImplements(peer))
 }

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

@@ -22,17 +22,17 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { TypeNode } from "./TypeNode"
 export class TSConditionalType extends TypeNode {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 110)
         super(pointer)
     }
@@ -58,6 +58,6 @@ export class TSConditionalType extends TypeNode {
 export function isTSConditionalType(node: object | undefined): node is TSConditionalType {
     return node instanceof TSConditionalType
 }
-if (!nodeByType.has(110)) {
-    nodeByType.set(110, TSConditionalType)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_CONDITIONAL_TYPE)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_CONDITIONAL_TYPE, (peer: KNativePointer) => new TSConditionalType(peer))
 }

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

@@ -22,19 +22,19 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { FunctionSignature } from "./FunctionSignature"
 import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration"
 import { TypeNode } from "./TypeNode"
 export class TSConstructorType extends TypeNode {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 125)
         super(pointer)
     }
@@ -45,13 +45,13 @@ export class TSConstructorType extends TypeNode {
         return new TSConstructorType(global.generatedEs2panda._UpdateTSConstructorType(global.context, passNode(original), passNode(signature), abstract))
     }
     get typeParams(): TSTypeParameterDeclaration | undefined {
-        return unpackNode(global.generatedEs2panda._TSConstructorTypeTypeParamsConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSConstructorTypeTypeParams(global.context, this.peer))
     }
     get params(): readonly Expression[] {
         return unpackNodeArray(global.generatedEs2panda._TSConstructorTypeParamsConst(global.context, this.peer))
     }
     get returnType(): TypeNode | undefined {
-        return unpackNode(global.generatedEs2panda._TSConstructorTypeReturnTypeConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSConstructorTypeReturnType(global.context, this.peer))
     }
     get abstract(): boolean {
         return global.generatedEs2panda._TSConstructorTypeAbstractConst(global.context, this.peer)
@@ -60,6 +60,6 @@ export class TSConstructorType extends TypeNode {
 export function isTSConstructorType(node: object | undefined): node is TSConstructorType {
     return node instanceof TSConstructorType
 }
-if (!nodeByType.has(125)) {
-    nodeByType.set(125, TSConstructorType)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_CONSTRUCTOR_TYPE)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_CONSTRUCTOR_TYPE, (peer: KNativePointer) => new TSConstructorType(peer))
 }

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -31,10 +30,11 @@ import {
 
 import { ClassDefinition } from "./ClassDefinition"
 import { Decorator } from "./Decorator"
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Identifier } from "./Identifier"
 import { TypedStatement } from "./TypedStatement"
 export class TSEnumDeclaration extends TypedStatement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 86)
         super(pointer)
     }
@@ -45,7 +45,7 @@ export class TSEnumDeclaration extends TypedStatement {
         return new TSEnumDeclaration(global.generatedEs2panda._UpdateTSEnumDeclaration(global.context, passNode(original), passNode(key), passNodeArray(members), members.length, isConst, isStatic, isDeclare))
     }
     get key(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._TSEnumDeclarationKeyConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSEnumDeclarationKey(global.context, this.peer))
     }
     get members(): readonly AstNode[] {
         return unpackNodeArray(global.generatedEs2panda._TSEnumDeclarationMembersConst(global.context, this.peer))
@@ -76,6 +76,6 @@ export class TSEnumDeclaration extends TypedStatement {
 export function isTSEnumDeclaration(node: object | undefined): node is TSEnumDeclaration {
     return node instanceof TSEnumDeclaration
 }
-if (!nodeByType.has(86)) {
-    nodeByType.set(86, TSEnumDeclaration)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_DECLARATION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_DECLARATION, (peer: KNativePointer) => new TSEnumDeclaration(peer))
 }

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

@@ -22,17 +22,17 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { Statement } from "./Statement"
 export class TSEnumMember extends Statement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 87)
         super(pointer)
     }
@@ -46,10 +46,10 @@ export class TSEnumMember extends Statement {
         return new TSEnumMember(global.generatedEs2panda._UpdateTSEnumMember1(global.context, passNode(original), passNode(key), passNode(init), isGenerated))
     }
     get key(): Expression | undefined {
-        return unpackNode(global.generatedEs2panda._TSEnumMemberKeyConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSEnumMemberKey(global.context, this.peer))
     }
     get init(): Expression | undefined {
-        return unpackNode(global.generatedEs2panda._TSEnumMemberInitConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSEnumMemberInit(global.context, this.peer))
     }
     get isGenerated(): boolean {
         return global.generatedEs2panda._TSEnumMemberIsGeneratedConst(global.context, this.peer)
@@ -61,6 +61,6 @@ export class TSEnumMember extends Statement {
 export function isTSEnumMember(node: object | undefined): node is TSEnumMember {
     return node instanceof TSEnumMember
 }
-if (!nodeByType.has(87)) {
-    nodeByType.set(87, TSEnumMember)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_MEMBER)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_MEMBER, (peer: KNativePointer) => new TSEnumMember(peer))
 }

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

@@ -22,16 +22,16 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 export class TSExternalModuleReference extends Expression {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 88)
         super(pointer)
     }
@@ -48,6 +48,6 @@ export class TSExternalModuleReference extends Expression {
 export function isTSExternalModuleReference(node: object | undefined): node is TSExternalModuleReference {
     return node instanceof TSExternalModuleReference
 }
-if (!nodeByType.has(88)) {
-    nodeByType.set(88, TSExternalModuleReference)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_EXTERNAL_MODULE_REFERENCE)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_EXTERNAL_MODULE_REFERENCE, (peer: KNativePointer) => new TSExternalModuleReference(peer))
 }

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

@@ -22,19 +22,19 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { FunctionSignature } from "./FunctionSignature"
 import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration"
 import { TypeNode } from "./TypeNode"
 export class TSFunctionType extends TypeNode {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 124)
         super(pointer)
     }
@@ -45,13 +45,13 @@ export class TSFunctionType extends TypeNode {
         return new TSFunctionType(global.generatedEs2panda._UpdateTSFunctionType(global.context, passNode(original), passNode(signature)))
     }
     get typeParams(): TSTypeParameterDeclaration | undefined {
-        return unpackNode(global.generatedEs2panda._TSFunctionTypeTypeParamsConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSFunctionTypeTypeParams(global.context, this.peer))
     }
     get params(): readonly Expression[] {
         return unpackNodeArray(global.generatedEs2panda._TSFunctionTypeParamsConst(global.context, this.peer))
     }
     get returnType(): TypeNode | undefined {
-        return unpackNode(global.generatedEs2panda._TSFunctionTypeReturnTypeConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSFunctionTypeReturnType(global.context, this.peer))
     }
     /** @deprecated */
     setNullable(nullable: boolean): this {
@@ -62,6 +62,6 @@ export class TSFunctionType extends TypeNode {
 export function isTSFunctionType(node: object | undefined): node is TSFunctionType {
     return node instanceof TSFunctionType
 }
-if (!nodeByType.has(124)) {
-    nodeByType.set(124, TSFunctionType)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_FUNCTION_TYPE)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_FUNCTION_TYPE, (peer: KNativePointer) => new TSFunctionType(peer))
 }

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

@@ -22,18 +22,18 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { Identifier } from "./Identifier"
 import { Statement } from "./Statement"
 export class TSImportEqualsDeclaration extends Statement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 123)
         super(pointer)
     }
@@ -56,6 +56,6 @@ export class TSImportEqualsDeclaration extends Statement {
 export function isTSImportEqualsDeclaration(node: object | undefined): node is TSImportEqualsDeclaration {
     return node instanceof TSImportEqualsDeclaration
 }
-if (!nodeByType.has(123)) {
-    nodeByType.set(123, TSImportEqualsDeclaration)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_IMPORT_EQUALS_DECLARATION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_IMPORT_EQUALS_DECLARATION, (peer: KNativePointer) => new TSImportEqualsDeclaration(peer))
 }

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

@@ -22,18 +22,18 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation"
 import { TypeNode } from "./TypeNode"
 export class TSImportType extends TypeNode {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 111)
         super(pointer)
     }
@@ -59,6 +59,6 @@ export class TSImportType extends TypeNode {
 export function isTSImportType(node: object | undefined): node is TSImportType {
     return node instanceof TSImportType
 }
-if (!nodeByType.has(111)) {
-    nodeByType.set(111, TSImportType)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_IMPORT_TYPE)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_IMPORT_TYPE, (peer: KNativePointer) => new TSImportType(peer))
 }

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

@@ -22,19 +22,19 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Es2pandaTSIndexSignatureKind } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { TypeNode } from "./TypeNode"
 import { TypedAstNode } from "./TypedAstNode"
 export class TSIndexSignature extends TypedAstNode {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 135)
         super(pointer)
     }
@@ -60,6 +60,6 @@ export class TSIndexSignature extends TypedAstNode {
 export function isTSIndexSignature(node: object | undefined): node is TSIndexSignature {
     return node instanceof TSIndexSignature
 }
-if (!nodeByType.has(135)) {
-    nodeByType.set(135, TSIndexSignature)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INDEX_SIGNATURE)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INDEX_SIGNATURE, (peer: KNativePointer) => new TSIndexSignature(peer))
 }

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

@@ -22,16 +22,16 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 export class TSIndexedAccessType extends TypeNode {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 129)
         super(pointer)
     }
@@ -51,6 +51,6 @@ export class TSIndexedAccessType extends TypeNode {
 export function isTSIndexedAccessType(node: object | undefined): node is TSIndexedAccessType {
     return node instanceof TSIndexedAccessType
 }
-if (!nodeByType.has(129)) {
-    nodeByType.set(129, TSIndexedAccessType)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INDEXED_ACCESS_TYPE)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INDEXED_ACCESS_TYPE, (peer: KNativePointer) => new TSIndexedAccessType(peer))
 }

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

@@ -22,17 +22,17 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TSTypeParameter } from "./TSTypeParameter"
 import { TypeNode } from "./TypeNode"
 export class TSInferType extends TypeNode {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 109)
         super(pointer)
     }
@@ -49,6 +49,6 @@ export class TSInferType extends TypeNode {
 export function isTSInferType(node: object | undefined): node is TSInferType {
     return node instanceof TSInferType
 }
-if (!nodeByType.has(109)) {
-    nodeByType.set(109, TSInferType)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INFER_TYPE)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INFER_TYPE, (peer: KNativePointer) => new TSInferType(peer))
 }

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

@@ -22,16 +22,16 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 export class TSInterfaceBody extends Expression {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 131)
         super(pointer)
     }
@@ -42,12 +42,12 @@ export class TSInterfaceBody extends Expression {
         return new TSInterfaceBody(global.generatedEs2panda._UpdateTSInterfaceBody(global.context, passNode(original), passNodeArray(body), body.length))
     }
     get body(): readonly AstNode[] {
-        return unpackNodeArray(global.generatedEs2panda._TSInterfaceBodyBodyConst(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._TSInterfaceBodyBody(global.context, this.peer))
     }
 }
 export function isTSInterfaceBody(node: object | undefined): node is TSInterfaceBody {
     return node instanceof TSInterfaceBody
 }
-if (!nodeByType.has(131)) {
-    nodeByType.set(131, TSInterfaceBody)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_BODY)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_BODY, (peer: KNativePointer) => new TSInterfaceBody(peer))
 }

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -32,13 +31,14 @@ import {
 import { AnnotationUsage } from "./AnnotationUsage"
 import { ClassDeclaration } from "./ClassDeclaration"
 import { Decorator } from "./Decorator"
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Identifier } from "./Identifier"
 import { TSInterfaceBody } from "./TSInterfaceBody"
 import { TSInterfaceHeritage } from "./TSInterfaceHeritage"
 import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration"
 import { TypedStatement } from "./TypedStatement"
 export class TSInterfaceDeclaration extends TypedStatement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 130)
         super(pointer)
     }
@@ -49,10 +49,10 @@ export class TSInterfaceDeclaration extends TypedStatement {
         return new TSInterfaceDeclaration(global.generatedEs2panda._UpdateTSInterfaceDeclaration(global.context, passNode(original), passNodeArray(_extends), _extends.length, passNode(id), passNode(typeParams), passNode(body), isStatic, isExternal))
     }
     get body(): TSInterfaceBody | undefined {
-        return unpackNode(global.generatedEs2panda._TSInterfaceDeclarationBodyConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSInterfaceDeclarationBody(global.context, this.peer))
     }
     get id(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._TSInterfaceDeclarationIdConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSInterfaceDeclarationId(global.context, this.peer))
     }
     get internalName(): string {
         return unpackString(global.generatedEs2panda._TSInterfaceDeclarationInternalNameConst(global.context, this.peer))
@@ -69,16 +69,16 @@ export class TSInterfaceDeclaration extends TypedStatement {
         return global.generatedEs2panda._TSInterfaceDeclarationIsFromExternalConst(global.context, this.peer)
     }
     get typeParams(): TSTypeParameterDeclaration | undefined {
-        return unpackNode(global.generatedEs2panda._TSInterfaceDeclarationTypeParamsConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSInterfaceDeclarationTypeParams(global.context, this.peer))
     }
     get extends(): readonly TSInterfaceHeritage[] {
-        return unpackNodeArray(global.generatedEs2panda._TSInterfaceDeclarationExtendsConst(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._TSInterfaceDeclarationExtends(global.context, this.peer))
     }
     get decorators(): readonly Decorator[] {
         return unpackNodeArray(global.generatedEs2panda._TSInterfaceDeclarationDecoratorsConst(global.context, this.peer))
     }
     get anonClass(): ClassDeclaration | undefined {
-        return unpackNode(global.generatedEs2panda._TSInterfaceDeclarationGetAnonClassConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._TSInterfaceDeclarationGetAnonClass(global.context, this.peer))
     }
     /** @deprecated */
     setAnonClass(anonClass?: ClassDeclaration): this {
@@ -86,7 +86,7 @@ export class TSInterfaceDeclaration extends TypedStatement {
         return this
     }
     get annotations(): readonly AnnotationUsage[] {
-        return unpackNodeArray(global.generatedEs2panda._TSInterfaceDeclarationAnnotationsConst(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._TSInterfaceDeclarationAnnotations(global.context, this.peer))
     }
     /** @deprecated */
     setAnnotations(annotations: readonly AnnotationUsage[]): this {
@@ -97,6 +97,6 @@ export class TSInterfaceDeclaration extends TypedStatement {
 export function isTSInterfaceDeclaration(node: object | undefined): node is TSInterfaceDeclaration {
     return node instanceof TSInterfaceDeclaration
 }
-if (!nodeByType.has(130)) {
-    nodeByType.set(130, TSInterfaceDeclaration)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_DECLARATION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_DECLARATION, (peer: KNativePointer) => new TSInterfaceDeclaration(peer))
 }