@idlizer/arktscgen 2.1.2 → 2.1.5

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

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+    global,
+    passNode,
+    passNodeArray,
+    unpackNonNullableNode,
+    unpackNode,
+    unpackNodeArray,
+    assertValidPeer,
+    AstNode,
+    KNativePointer,
+    nodeByType,
+    ArktsObject,
+    unpackString
+} from "../../reexport-for-generated"
+
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
+import { TypeNode } from "./TypeNode"
+export class ETSStringLiteralType extends TypeNode {
+    constructor(pointer: KNativePointer) {
+        assertValidPeer(pointer, 65)
+        super(pointer)
+    }
+    static createETSStringLiteralType(value: string): ETSStringLiteralType {
+        return new ETSStringLiteralType(global.generatedEs2panda._CreateETSStringLiteralType(global.context, value))
+    }
+    static updateETSStringLiteralType(original: ETSStringLiteralType | undefined, value: string): ETSStringLiteralType {
+        return new ETSStringLiteralType(global.generatedEs2panda._UpdateETSStringLiteralType(global.context, passNode(original), value))
+    }
+}
+export function isETSStringLiteralType(node: object | undefined): node is ETSStringLiteralType {
+    return node instanceof ETSStringLiteralType
+}
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_STRING_LITERAL_TYPE)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_STRING_LITERAL_TYPE, (peer: KNativePointer) => new ETSStringLiteralType(peer))
+}

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -31,8 +30,9 @@ import {
 
 import { ClassDeclaration } from "./ClassDeclaration"
 import { ClassDefinition } from "./ClassDefinition"
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 export class ETSStructDeclaration extends ClassDeclaration {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 83)
         super(pointer)
     }
@@ -46,6 +46,6 @@ export class ETSStructDeclaration extends ClassDeclaration {
 export function isETSStructDeclaration(node: object | undefined): node is ETSStructDeclaration {
     return node instanceof ETSStructDeclaration
 }
-if (!nodeByType.has(83)) {
-    nodeByType.set(83, ETSStructDeclaration)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_STRUCT_DECLARATION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_STRUCT_DECLARATION, (peer: KNativePointer) => new ETSStructDeclaration(peer))
 }

package/build/libarkts-copy/src/generated/peers/ETSTuple.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 ETSTuple extends TypeNode {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 80)
         super(pointer)
     }
@@ -57,7 +57,7 @@ export class ETSTuple extends TypeNode {
         return global.generatedEs2panda._ETSTupleGetTupleSizeConst(global.context, this.peer)
     }
     get tupleTypeAnnotationsList(): readonly TypeNode[] {
-        return unpackNodeArray(global.generatedEs2panda._ETSTupleGetTupleTypeAnnotationsListConst(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._ETSTupleGetTupleTypeAnnotationsList(global.context, this.peer))
     }
     /** @deprecated */
     setTypeAnnotationsList(typeNodeList: readonly TypeNode[]): this {
@@ -68,6 +68,6 @@ export class ETSTuple extends TypeNode {
 export function isETSTuple(node: object | undefined): node is ETSTuple {
     return node instanceof ETSTuple
 }
-if (!nodeByType.has(80)) {
-    nodeByType.set(80, ETSTuple)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TUPLE)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TUPLE, (peer: KNativePointer) => new ETSTuple(peer))
 }

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -30,10 +29,11 @@ import {
 } from "../../reexport-for-generated"
 
 import { ETSTypeReferencePart } from "./ETSTypeReferencePart"
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Identifier } from "./Identifier"
 import { TypeNode } from "./TypeNode"
 export class ETSTypeReference extends TypeNode {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 71)
         super(pointer)
     }
@@ -44,7 +44,7 @@ export class ETSTypeReference extends TypeNode {
         return new ETSTypeReference(global.generatedEs2panda._UpdateETSTypeReference(global.context, passNode(original), passNode(part)))
     }
     get part(): ETSTypeReferencePart | undefined {
-        return unpackNode(global.generatedEs2panda._ETSTypeReferencePartConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ETSTypeReferencePart(global.context, this.peer))
     }
     get baseName(): Identifier | undefined {
         return unpackNode(global.generatedEs2panda._ETSTypeReferenceBaseNameConst(global.context, this.peer))
@@ -53,6 +53,6 @@ export class ETSTypeReference extends TypeNode {
 export function isETSTypeReference(node: object | undefined): node is ETSTypeReference {
     return node instanceof ETSTypeReference
 }
-if (!nodeByType.has(71)) {
-    nodeByType.set(71, ETSTypeReference)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE, (peer: KNativePointer) => new ETSTypeReference(peer))
 }

package/build/libarkts-copy/src/generated/peers/ETSTypeReferencePart.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 { Identifier } from "./Identifier"
 import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation"
 import { TypeNode } from "./TypeNode"
 export class ETSTypeReferencePart extends TypeNode {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 72)
         super(pointer)
     }
@@ -48,14 +48,14 @@ export class ETSTypeReferencePart extends TypeNode {
         return new ETSTypeReferencePart(global.generatedEs2panda._UpdateETSTypeReferencePart1(global.context, passNode(original), passNode(name)))
     }
     get previous(): ETSTypeReferencePart | undefined {
-        return unpackNode(global.generatedEs2panda._ETSTypeReferencePartPreviousConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ETSTypeReferencePartPrevious(global.context, this.peer))
+    }
+    get name(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._ETSTypeReferencePartName(global.context, this.peer))
     }
     get typeParams(): TSTypeParameterInstantiation | undefined {
         return unpackNode(global.generatedEs2panda._ETSTypeReferencePartTypeParams(global.context, this.peer))
     }
-    get name(): Expression | undefined {
-        return unpackNode(global.generatedEs2panda._ETSTypeReferencePartNameConst(global.context, this.peer))
-    }
     get ident(): Identifier | undefined {
         return unpackNode(global.generatedEs2panda._ETSTypeReferencePartGetIdent(global.context, this.peer))
     }
@@ -63,6 +63,6 @@ export class ETSTypeReferencePart extends TypeNode {
 export function isETSTypeReferencePart(node: object | undefined): node is ETSTypeReferencePart {
     return node instanceof ETSTypeReferencePart
 }
-if (!nodeByType.has(72)) {
-    nodeByType.set(72, ETSTypeReferencePart)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE_PART)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE_PART, (peer: KNativePointer) => new ETSTypeReferencePart(peer))
 }

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

@@ -22,29 +22,29 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 export class ETSUndefinedType extends TypeNode {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 63)
         super(pointer)
     }
     static createETSUndefinedType(): ETSUndefinedType {
-        return new ETSUndefinedType(global.generatedEs2panda._CreateETSUndefinedTypeIr(global.context))
+        return new ETSUndefinedType(global.generatedEs2panda._CreateETSUndefinedType(global.context))
     }
     static updateETSUndefinedType(original?: ETSUndefinedType): ETSUndefinedType {
-        return new ETSUndefinedType(global.generatedEs2panda._UpdateETSUndefinedTypeIr(global.context, passNode(original)))
+        return new ETSUndefinedType(global.generatedEs2panda._UpdateETSUndefinedType(global.context, passNode(original)))
     }
 }
 export function isETSUndefinedType(node: object | undefined): node is ETSUndefinedType {
     return node instanceof ETSUndefinedType
 }
-if (!nodeByType.has(63)) {
-    nodeByType.set(63, ETSUndefinedType)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNDEFINED_TYPE)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNDEFINED_TYPE, (peer: KNativePointer) => new ETSUndefinedType(peer))
 }

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

@@ -22,32 +22,32 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 export class ETSUnionType extends TypeNode {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 73)
         super(pointer)
     }
     static createETSUnionType(types: readonly TypeNode[]): ETSUnionType {
-        return new ETSUnionType(global.generatedEs2panda._CreateETSUnionTypeIr(global.context, passNodeArray(types), types.length))
+        return new ETSUnionType(global.generatedEs2panda._CreateETSUnionType(global.context, passNodeArray(types), types.length))
     }
     static updateETSUnionType(original: ETSUnionType | undefined, types: readonly TypeNode[]): ETSUnionType {
-        return new ETSUnionType(global.generatedEs2panda._UpdateETSUnionTypeIr(global.context, passNode(original), passNodeArray(types), types.length))
+        return new ETSUnionType(global.generatedEs2panda._UpdateETSUnionType(global.context, passNode(original), passNodeArray(types), types.length))
     }
     get types(): readonly TypeNode[] {
-        return unpackNodeArray(global.generatedEs2panda._ETSUnionTypeIrTypesConst(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._ETSUnionTypeTypesConst(global.context, this.peer))
     }
 }
 export function isETSUnionType(node: object | undefined): node is ETSUnionType {
     return node instanceof ETSUnionType
 }
-if (!nodeByType.has(73)) {
-    nodeByType.set(73, ETSUnionType)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNION_TYPE)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNION_TYPE, (peer: KNativePointer) => new ETSUnionType(peer))
 }

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -30,10 +29,11 @@ import {
 } from "../../reexport-for-generated"
 
 import { ETSTypeReference } from "./ETSTypeReference"
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Es2pandaModifierFlags } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 export class ETSWildcardType extends TypeNode {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 67)
         super(pointer)
     }
@@ -44,12 +44,12 @@ export class ETSWildcardType extends TypeNode {
         return new ETSWildcardType(global.generatedEs2panda._UpdateETSWildcardType(global.context, passNode(original), passNode(typeReference), flags))
     }
     get typeReference(): ETSTypeReference | undefined {
-        return unpackNode(global.generatedEs2panda._ETSWildcardTypeTypeReferenceConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ETSWildcardTypeTypeReference(global.context, this.peer))
     }
 }
 export function isETSWildcardType(node: object | undefined): node is ETSWildcardType {
     return node instanceof ETSWildcardType
 }
-if (!nodeByType.has(67)) {
-    nodeByType.set(67, ETSWildcardType)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_WILDCARD_TYPE)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_WILDCARD_TYPE, (peer: KNativePointer) => new ETSWildcardType(peer))
 }

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

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

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

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+    global,
+    passNode,
+    passNodeArray,
+    unpackNonNullableNode,
+    unpackNode,
+    unpackNodeArray,
+    assertValidPeer,
+    AstNode,
+    KNativePointer,
+    nodeByType,
+    ArktsObject,
+    unpackString
+} from "../../reexport-for-generated"
+
+export class ErrorLogger extends ArktsObject {
+    constructor(pointer: KNativePointer) {
+        super(pointer)
+    }
+}

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

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

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

@@ -22,16 +22,16 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Statement } from "./Statement"
 export class ExportDefaultDeclaration extends Statement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 27)
         super(pointer)
     }
@@ -42,7 +42,7 @@ export class ExportDefaultDeclaration extends Statement {
         return new ExportDefaultDeclaration(global.generatedEs2panda._UpdateExportDefaultDeclaration(global.context, passNode(original), passNode(decl), exportEquals))
     }
     get decl(): AstNode | undefined {
-        return unpackNode(global.generatedEs2panda._ExportDefaultDeclarationDeclConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ExportDefaultDeclarationDecl(global.context, this.peer))
     }
     get isExportEquals(): boolean {
         return global.generatedEs2panda._ExportDefaultDeclarationIsExportEqualsConst(global.context, this.peer)
@@ -51,6 +51,6 @@ export class ExportDefaultDeclaration extends Statement {
 export function isExportDefaultDeclaration(node: object | undefined): node is ExportDefaultDeclaration {
     return node instanceof ExportDefaultDeclaration
 }
-if (!nodeByType.has(27)) {
-    nodeByType.set(27, ExportDefaultDeclaration)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_DEFAULT_DECLARATION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_DEFAULT_DECLARATION, (peer: KNativePointer) => new ExportDefaultDeclaration(peer))
 }

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

@@ -22,18 +22,18 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { ExportSpecifier } from "./ExportSpecifier"
 import { Statement } from "./Statement"
 import { StringLiteral } from "./StringLiteral"
 export class ExportNamedDeclaration extends Statement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 28)
         super(pointer)
     }
@@ -68,6 +68,6 @@ export class ExportNamedDeclaration extends Statement {
 export function isExportNamedDeclaration(node: object | undefined): node is ExportNamedDeclaration {
     return node instanceof ExportNamedDeclaration
 }
-if (!nodeByType.has(28)) {
-    nodeByType.set(28, ExportNamedDeclaration)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_NAMED_DECLARATION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_NAMED_DECLARATION, (peer: KNativePointer) => new ExportNamedDeclaration(peer))
 }

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

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

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -34,7 +33,7 @@ import { Literal } from "./Literal"
 import { TypeNode } from "./TypeNode"
 import { TypedAstNode } from "./TypedAstNode"
 export class Expression extends TypedAstNode {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         super(pointer)
     }
     get isGrouped(): boolean {
@@ -46,7 +45,7 @@ export class Expression extends TypedAstNode {
         return this
     }
     get asLiteral(): Literal | undefined {
-        return unpackNode(global.generatedEs2panda._ExpressionAsLiteralConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ExpressionAsLiteral(global.context, this.peer))
     }
     get isLiteral(): boolean {
         return global.generatedEs2panda._ExpressionIsLiteralConst(global.context, this.peer)
@@ -58,10 +57,10 @@ export class Expression extends TypedAstNode {
         return global.generatedEs2panda._ExpressionIsAnnotatedExpressionConst(global.context, this.peer)
     }
     get asTypeNode(): TypeNode | undefined {
-        return unpackNode(global.generatedEs2panda._ExpressionAsTypeNodeConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ExpressionAsTypeNode(global.context, this.peer))
     }
     get asAnnotatedExpression(): AnnotatedExpression | undefined {
-        return unpackNode(global.generatedEs2panda._ExpressionAsAnnotatedExpressionConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ExpressionAsAnnotatedExpression(global.context, this.peer))
     }
     get isBrokenExpression(): boolean {
         return global.generatedEs2panda._ExpressionIsBrokenExpressionConst(global.context, this.peer)

package/build/libarkts-copy/src/generated/peers/ExpressionStatement.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 ExpressionStatement extends Statement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 30)
         super(pointer)
     }
@@ -42,8 +42,8 @@ export class ExpressionStatement extends Statement {
     static updateExpressionStatement(original?: ExpressionStatement, expr?: Expression): ExpressionStatement {
         return new ExpressionStatement(global.generatedEs2panda._UpdateExpressionStatement(global.context, passNode(original), passNode(expr)))
     }
-    get expression(): Expression {
-        return unpackNonNullableNode(global.generatedEs2panda._ExpressionStatementGetExpressionConst(global.context, this.peer))
+    get expression(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._ExpressionStatementGetExpression(global.context, this.peer))
     }
     /** @deprecated */
     setExpression(expr?: Expression): this {
@@ -54,6 +54,6 @@ export class ExpressionStatement extends Statement {
 export function isExpressionStatement(node: object | undefined): node is ExpressionStatement {
     return node instanceof ExpressionStatement
 }
-if (!nodeByType.has(30)) {
-    nodeByType.set(30, ExpressionStatement)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_EXPRESSION_STATEMENT)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_EXPRESSION_STATEMENT, (peer: KNativePointer) => new ExpressionStatement(peer))
 }

package/build/libarkts-copy/src/generated/peers/ForInStatement.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 { LoopStatement } from "./LoopStatement"
 import { Statement } from "./Statement"
 export class ForInStatement extends LoopStatement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 31)
         super(pointer)
     }
@@ -44,18 +44,18 @@ export class ForInStatement extends LoopStatement {
         return new ForInStatement(global.generatedEs2panda._UpdateForInStatement(global.context, passNode(original), passNode(left), passNode(right), passNode(body)))
     }
     get left(): AstNode | undefined {
-        return unpackNode(global.generatedEs2panda._ForInStatementLeftConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ForInStatementLeft(global.context, this.peer))
     }
     get right(): Expression | undefined {
-        return unpackNode(global.generatedEs2panda._ForInStatementRightConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ForInStatementRight(global.context, this.peer))
     }
     get body(): Statement | undefined {
-        return unpackNode(global.generatedEs2panda._ForInStatementBodyConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ForInStatementBody(global.context, this.peer))
     }
 }
 export function isForInStatement(node: object | undefined): node is ForInStatement {
     return node instanceof ForInStatement
 }
-if (!nodeByType.has(31)) {
-    nodeByType.set(31, ForInStatement)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_FOR_IN_STATEMENT)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_FOR_IN_STATEMENT, (peer: KNativePointer) => new ForInStatement(peer))
 }