@idlizer/arktscgen 2.1.2 → 2.1.5

package/build/libarkts-copy/src/generated/peers/ForOfStatement.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 ForOfStatement extends LoopStatement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 32)
         super(pointer)
     }
@@ -44,13 +44,13 @@ export class ForOfStatement extends LoopStatement {
         return new ForOfStatement(global.generatedEs2panda._UpdateForOfStatement(global.context, passNode(original), passNode(left), passNode(right), passNode(body), isAwait))
     }
     get left(): AstNode | undefined {
-        return unpackNode(global.generatedEs2panda._ForOfStatementLeftConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ForOfStatementLeft(global.context, this.peer))
     }
     get right(): Expression | undefined {
-        return unpackNode(global.generatedEs2panda._ForOfStatementRightConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ForOfStatementRight(global.context, this.peer))
     }
     get body(): Statement | undefined {
-        return unpackNode(global.generatedEs2panda._ForOfStatementBodyConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ForOfStatementBody(global.context, this.peer))
     }
     get isAwait(): boolean {
         return global.generatedEs2panda._ForOfStatementIsAwaitConst(global.context, this.peer)
@@ -59,6 +59,6 @@ export class ForOfStatement extends LoopStatement {
 export function isForOfStatement(node: object | undefined): node is ForOfStatement {
     return node instanceof ForOfStatement
 }
-if (!nodeByType.has(32)) {
-    nodeByType.set(32, ForOfStatement)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_FOR_OF_STATEMENT)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_FOR_OF_STATEMENT, (peer: KNativePointer) => new ForOfStatement(peer))
 }

package/build/libarkts-copy/src/generated/peers/ForUpdateStatement.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 ForUpdateStatement extends LoopStatement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 33)
         super(pointer)
     }
@@ -41,21 +41,21 @@ export class ForUpdateStatement extends LoopStatement {
         return new ForUpdateStatement(global.generatedEs2panda._CreateForUpdateStatement(global.context, passNode(init), passNode(test), passNode(update), passNode(body)))
     }
     get init(): AstNode | undefined {
-        return unpackNode(global.generatedEs2panda._ForUpdateStatementInitConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ForUpdateStatementInit(global.context, this.peer))
     }
     get test(): Expression | undefined {
-        return unpackNode(global.generatedEs2panda._ForUpdateStatementTestConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ForUpdateStatementTest(global.context, this.peer))
     }
     get update(): Expression | undefined {
         return unpackNode(global.generatedEs2panda._ForUpdateStatementUpdateConst(global.context, this.peer))
     }
     get body(): Statement | undefined {
-        return unpackNode(global.generatedEs2panda._ForUpdateStatementBodyConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ForUpdateStatementBody(global.context, this.peer))
     }
 }
 export function isForUpdateStatement(node: object | undefined): node is ForUpdateStatement {
     return node instanceof ForUpdateStatement
 }
-if (!nodeByType.has(33)) {
-    nodeByType.set(33, ForUpdateStatement)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_FOR_UPDATE_STATEMENT)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_FOR_UPDATE_STATEMENT, (peer: KNativePointer) => new ForUpdateStatement(peer))
 }

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -31,7 +30,7 @@ import {
 
 import { ScriptFunction } from "./ScriptFunction"
 export class FunctionDecl extends ScriptFunction {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         super(pointer)
     }
 }

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -30,10 +29,11 @@ import {
 } from "../../reexport-for-generated"
 
 import { AnnotationUsage } from "./AnnotationUsage"
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { ScriptFunction } from "./ScriptFunction"
 import { Statement } from "./Statement"
 export class FunctionDeclaration extends Statement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 34)
         super(pointer)
     }
@@ -46,14 +46,14 @@ export class FunctionDeclaration extends Statement {
     static update1FunctionDeclaration(original: FunctionDeclaration | undefined, func: ScriptFunction | undefined, isAnonymous: boolean): FunctionDeclaration {
         return new FunctionDeclaration(global.generatedEs2panda._UpdateFunctionDeclaration1(global.context, passNode(original), passNode(func), isAnonymous))
     }
+    get function(): ScriptFunction | undefined {
+        return unpackNode(global.generatedEs2panda._FunctionDeclarationFunction(global.context, this.peer))
+    }
     get isAnonymous(): boolean {
         return global.generatedEs2panda._FunctionDeclarationIsAnonymousConst(global.context, this.peer)
     }
-    get function(): ScriptFunction {
-        return unpackNonNullableNode(global.generatedEs2panda._FunctionDeclarationFunctionConst(global.context, this.peer))
-    }
     get annotations(): readonly AnnotationUsage[] {
-        return unpackNodeArray(global.generatedEs2panda._FunctionDeclarationAnnotationsConst(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._FunctionDeclarationAnnotations(global.context, this.peer))
     }
     /** @deprecated */
     setAnnotations(annotations: readonly AnnotationUsage[]): this {
@@ -64,6 +64,6 @@ export class FunctionDeclaration extends Statement {
 export function isFunctionDeclaration(node: object | undefined): node is FunctionDeclaration {
     return node instanceof FunctionDeclaration
 }
-if (!nodeByType.has(34)) {
-    nodeByType.set(34, FunctionDeclaration)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_DECLARATION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_DECLARATION, (peer: KNativePointer) => new FunctionDeclaration(peer))
 }

package/build/libarkts-copy/src/generated/peers/FunctionExpression.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 { ScriptFunction } from "./ScriptFunction"
 export class FunctionExpression extends Expression {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 35)
         super(pointer)
     }
@@ -47,7 +47,7 @@ export class FunctionExpression extends Expression {
         return new FunctionExpression(global.generatedEs2panda._UpdateFunctionExpression1(global.context, passNode(original), passNode(namedExpr), passNode(func)))
     }
     get function(): ScriptFunction | undefined {
-        return unpackNode(global.generatedEs2panda._FunctionExpressionFunctionConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._FunctionExpressionFunction(global.context, this.peer))
     }
     get isAnonymous(): boolean {
         return global.generatedEs2panda._FunctionExpressionIsAnonymousConst(global.context, this.peer)
@@ -59,6 +59,6 @@ export class FunctionExpression extends Expression {
 export function isFunctionExpression(node: object | undefined): node is FunctionExpression {
     return node instanceof FunctionExpression
 }
-if (!nodeByType.has(35)) {
-    nodeByType.set(35, FunctionExpression)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_EXPRESSION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_EXPRESSION, (peer: KNativePointer) => new FunctionExpression(peer))
 }

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -33,26 +32,26 @@ import { Expression } from "./Expression"
 import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration"
 import { TypeNode } from "./TypeNode"
 export class FunctionSignature extends ArktsObject {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         super(pointer)
     }
     static createFunctionSignature(typeParams: TSTypeParameterDeclaration | undefined, params: readonly Expression[], returnTypeAnnotation: TypeNode | undefined, hasReceiver: boolean): FunctionSignature {
         return new FunctionSignature(global.generatedEs2panda._CreateFunctionSignature(global.context, passNode(typeParams), passNodeArray(params), params.length, passNode(returnTypeAnnotation), hasReceiver))
     }
     get params(): readonly Expression[] {
-        return unpackNodeArray(global.generatedEs2panda._FunctionSignatureParamsConst(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._FunctionSignatureParams(global.context, this.peer))
     }
     get typeParams(): TSTypeParameterDeclaration | undefined {
-        return unpackNode(global.generatedEs2panda._FunctionSignatureTypeParamsConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._FunctionSignatureTypeParams(global.context, this.peer))
+    }
+    get returnType(): TypeNode | undefined {
+        return unpackNode(global.generatedEs2panda._FunctionSignatureReturnType(global.context, this.peer))
     }
     /** @deprecated */
     setReturnType(type?: TypeNode): this {
         global.generatedEs2panda._FunctionSignatureSetReturnType(global.context, this.peer, passNode(type))
         return this
     }
-    get returnType(): TypeNode | undefined {
-        return unpackNode(global.generatedEs2panda._FunctionSignatureReturnTypeConst(global.context, this.peer))
-    }
     get clone(): FunctionSignature | undefined {
         return new FunctionSignature(global.generatedEs2panda._FunctionSignatureClone(global.context, this.peer))
     }

package/build/libarkts-copy/src/generated/peers/IRNode.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 IRNode extends ArktsObject {
+    constructor(pointer: KNativePointer) {
+        super(pointer)
+    }
+}

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -31,10 +30,11 @@ import {
 
 import { AnnotatedExpression } from "./AnnotatedExpression"
 import { Decorator } from "./Decorator"
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { TypeNode } from "./TypeNode"
 import { ValidationInfo } from "./ValidationInfo"
 export class Identifier extends AnnotatedExpression {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 36)
         super(pointer)
     }
@@ -51,7 +51,7 @@ export class Identifier extends AnnotatedExpression {
         return new Identifier(global.generatedEs2panda._UpdateIdentifier2(global.context, passNode(original), name, passNode(typeAnnotation)))
     }
     get name(): string {
-        return unpackString(global.generatedEs2panda._IdentifierNameConst(global.context, this.peer))
+        return unpackString(global.generatedEs2panda._IdentifierName(global.context, this.peer))
     }
     /** @deprecated */
     setName(newName: string): this {
@@ -149,6 +149,6 @@ export class Identifier extends AnnotatedExpression {
 export function isIdentifier(node: object | undefined): node is Identifier {
     return node instanceof Identifier
 }
-if (!nodeByType.has(36)) {
-    nodeByType.set(36, Identifier)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER, (peer: KNativePointer) => new Identifier(peer))
 }

package/build/libarkts-copy/src/generated/peers/IfStatement.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 IfStatement extends Statement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 38)
         super(pointer)
     }
@@ -42,14 +42,14 @@ export class IfStatement extends Statement {
     static updateIfStatement(original?: IfStatement, test?: Expression, consequent?: Statement, alternate?: Statement): IfStatement {
         return new IfStatement(global.generatedEs2panda._UpdateIfStatement(global.context, passNode(original), passNode(test), passNode(consequent), passNode(alternate)))
     }
-    get test(): Expression {
-        return unpackNonNullableNode(global.generatedEs2panda._IfStatementTestConst(global.context, this.peer))
+    get test(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._IfStatementTest(global.context, this.peer))
     }
-    get consequent(): Statement {
-        return unpackNonNullableNode(global.generatedEs2panda._IfStatementConsequentConst(global.context, this.peer))
+    get consequent(): Statement | undefined {
+        return unpackNode(global.generatedEs2panda._IfStatementConsequent(global.context, this.peer))
     }
     get alternate(): Statement | undefined {
-        return unpackNode(global.generatedEs2panda._IfStatementAlternateConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._IfStatementAlternate(global.context, this.peer))
     }
     /** @deprecated */
     setAlternate(alternate?: Statement): this {
@@ -60,6 +60,6 @@ export class IfStatement extends Statement {
 export function isIfStatement(node: object | undefined): node is IfStatement {
     return node instanceof IfStatement
 }
-if (!nodeByType.has(38)) {
-    nodeByType.set(38, IfStatement)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_IF_STATEMENT)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_IF_STATEMENT, (peer: KNativePointer) => new IfStatement(peer))
 }

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

@@ -22,32 +22,32 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Es2pandaImportKinds } from "./../Es2pandaEnums"
 import { Statement } from "./Statement"
 import { StringLiteral } from "./StringLiteral"
 export class ImportDeclaration extends Statement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 39)
         super(pointer)
     }
-    static createImportDeclaration(source: StringLiteral | undefined, specifiers: readonly AstNode[], importKind: Es2pandaImportKinds): ImportDeclaration {
-        return new ImportDeclaration(global.generatedEs2panda._CreateImportDeclaration(global.context, passNode(source), passNodeArray(specifiers), specifiers.length, importKind))
+    static createImportDeclaration(source: StringLiteral | undefined, specifiers: readonly AstNode[], importKinds: Es2pandaImportKinds): ImportDeclaration {
+        return new ImportDeclaration(global.generatedEs2panda._CreateImportDeclaration(global.context, passNode(source), passNodeArray(specifiers), specifiers.length, importKinds))
     }
-    static updateImportDeclaration(original: ImportDeclaration | undefined, source: StringLiteral | undefined, specifiers: readonly AstNode[], importKind: Es2pandaImportKinds): ImportDeclaration {
-        return new ImportDeclaration(global.generatedEs2panda._UpdateImportDeclaration(global.context, passNode(original), passNode(source), passNodeArray(specifiers), specifiers.length, importKind))
+    static updateImportDeclaration(original: ImportDeclaration | undefined, source: StringLiteral | undefined, specifiers: readonly AstNode[], importKinds: Es2pandaImportKinds): ImportDeclaration {
+        return new ImportDeclaration(global.generatedEs2panda._UpdateImportDeclaration(global.context, passNode(original), passNode(source), passNodeArray(specifiers), specifiers.length, importKinds))
     }
     get source(): StringLiteral | undefined {
-        return unpackNode(global.generatedEs2panda._ImportDeclarationSourceConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ImportDeclarationSource(global.context, this.peer))
     }
     get specifiers(): readonly AstNode[] {
-        return unpackNodeArray(global.generatedEs2panda._ImportDeclarationSpecifiersConst(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._ImportDeclarationSpecifiers(global.context, this.peer))
     }
     get isTypeKind(): boolean {
         return global.generatedEs2panda._ImportDeclarationIsTypeKindConst(global.context, this.peer)
@@ -56,6 +56,6 @@ export class ImportDeclaration extends Statement {
 export function isImportDeclaration(node: object | undefined): node is ImportDeclaration {
     return node instanceof ImportDeclaration
 }
-if (!nodeByType.has(39)) {
-    nodeByType.set(39, ImportDeclaration)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DECLARATION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DECLARATION, (peer: KNativePointer) => new ImportDeclaration(peer))
 }

package/build/libarkts-copy/src/generated/peers/ImportDefaultSpecifier.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 ImportDefaultSpecifier extends Statement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 41)
         super(pointer)
     }
@@ -43,12 +43,12 @@ export class ImportDefaultSpecifier extends Statement {
         return new ImportDefaultSpecifier(global.generatedEs2panda._UpdateImportDefaultSpecifier(global.context, passNode(original), passNode(local)))
     }
     get local(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._ImportDefaultSpecifierLocalConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ImportDefaultSpecifierLocal(global.context, this.peer))
     }
 }
 export function isImportDefaultSpecifier(node: object | undefined): node is ImportDefaultSpecifier {
     return node instanceof ImportDefaultSpecifier
 }
-if (!nodeByType.has(41)) {
-    nodeByType.set(41, ImportDefaultSpecifier)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DEFAULT_SPECIFIER)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DEFAULT_SPECIFIER, (peer: KNativePointer) => new ImportDefaultSpecifier(peer))
 }

package/build/libarkts-copy/src/generated/peers/ImportExpression.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 ImportExpression extends Expression {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 40)
         super(pointer)
     }
@@ -42,12 +42,12 @@ export class ImportExpression extends Expression {
         return new ImportExpression(global.generatedEs2panda._UpdateImportExpression(global.context, passNode(original), passNode(source)))
     }
     get source(): Expression | undefined {
-        return unpackNode(global.generatedEs2panda._ImportExpressionSourceConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ImportExpressionSource(global.context, this.peer))
     }
 }
 export function isImportExpression(node: object | undefined): node is ImportExpression {
     return node instanceof ImportExpression
 }
-if (!nodeByType.has(40)) {
-    nodeByType.set(40, ImportExpression)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_EXPRESSION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_EXPRESSION, (peer: KNativePointer) => new ImportExpression(peer))
 }

package/build/libarkts-copy/src/generated/peers/ImportNamespaceSpecifier.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 ImportNamespaceSpecifier extends Statement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 42)
         super(pointer)
     }
@@ -43,12 +43,12 @@ export class ImportNamespaceSpecifier extends Statement {
         return new ImportNamespaceSpecifier(global.generatedEs2panda._UpdateImportNamespaceSpecifier(global.context, passNode(original), passNode(local)))
     }
     get local(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._ImportNamespaceSpecifierLocalConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ImportNamespaceSpecifierLocal(global.context, this.peer))
     }
 }
 export function isImportNamespaceSpecifier(node: object | undefined): node is ImportNamespaceSpecifier {
     return node instanceof ImportNamespaceSpecifier
 }
-if (!nodeByType.has(42)) {
-    nodeByType.set(42, ImportNamespaceSpecifier)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_NAMESPACE_SPECIFIER)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_NAMESPACE_SPECIFIER, (peer: KNativePointer) => new ImportNamespaceSpecifier(peer))
 }

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

@@ -22,28 +22,14 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
-import { StringLiteral } from "./StringLiteral"
 export class ImportSource extends ArktsObject {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         super(pointer)
     }
-    static createImportSource(source: StringLiteral | undefined, resolvedSource: StringLiteral | undefined, hasDecl: boolean): ImportSource {
-        return new ImportSource(global.generatedEs2panda._CreateImportSource(global.context, passNode(source), passNode(resolvedSource), hasDecl))
-    }
-    get source(): StringLiteral | undefined {
-        return unpackNode(global.generatedEs2panda._ImportSourceSourceConst(global.context, this.peer))
-    }
-    get resolvedSource(): StringLiteral | undefined {
-        return unpackNode(global.generatedEs2panda._ImportSourceResolvedSourceConst(global.context, this.peer))
-    }
-    get hasDecl(): boolean {
-        return global.generatedEs2panda._ImportSourceHasDeclConst(global.context, this.peer)
-    }
 }

package/build/libarkts-copy/src/generated/peers/ImportSpecifier.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 ImportSpecifier extends Statement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 43)
         super(pointer)
     }
@@ -43,15 +43,23 @@ export class ImportSpecifier extends Statement {
         return new ImportSpecifier(global.generatedEs2panda._UpdateImportSpecifier(global.context, passNode(original), passNode(imported), passNode(local)))
     }
     get imported(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._ImportSpecifierImportedConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ImportSpecifierImported(global.context, this.peer))
     }
     get local(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._ImportSpecifierLocalConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._ImportSpecifierLocal(global.context, this.peer))
+    }
+    get isRemovable(): boolean {
+        return global.generatedEs2panda._ImportSpecifierIsRemovableConst(global.context, this.peer)
+    }
+    /** @deprecated */
+    setRemovable(isRemovable: boolean): this {
+        global.generatedEs2panda._ImportSpecifierSetRemovable(global.context, this.peer, isRemovable)
+        return this
     }
 }
 export function isImportSpecifier(node: object | undefined): node is ImportSpecifier {
     return node instanceof ImportSpecifier
 }
-if (!nodeByType.has(43)) {
-    nodeByType.set(43, ImportSpecifier)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_SPECIFIER)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_SPECIFIER, (peer: KNativePointer) => new ImportSpecifier(peer))
 }

package/build/libarkts-copy/src/generated/peers/IndexInfo.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 IndexInfo extends ArktsObject {
+    constructor(pointer: KNativePointer) {
+        super(pointer)
+    }
+}

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -31,7 +30,7 @@ import {
 
 import { TSInterfaceDeclaration } from "./TSInterfaceDeclaration"
 export class InterfaceDecl extends TSInterfaceDeclaration {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         super(pointer)
     }
 }