@idlizer/arktscgen 2.1.2 → 2.1.5

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

package/build/libarkts-copy/src/generated/peers/LabelledStatement.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 LabelledStatement extends Statement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 44)
         super(pointer)
     }
@@ -43,10 +43,10 @@ export class LabelledStatement extends Statement {
         return new LabelledStatement(global.generatedEs2panda._UpdateLabelledStatement(global.context, passNode(original), passNode(ident), passNode(body)))
     }
     get body(): Statement | undefined {
-        return unpackNode(global.generatedEs2panda._LabelledStatementBodyConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._LabelledStatementBody(global.context, this.peer))
     }
     get ident(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._LabelledStatementIdentConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._LabelledStatementIdent(global.context, this.peer))
     }
     get referencedStatement(): AstNode | undefined {
         return unpackNode(global.generatedEs2panda._LabelledStatementGetReferencedStatementConst(global.context, this.peer))
@@ -55,6 +55,6 @@ export class LabelledStatement extends Statement {
 export function isLabelledStatement(node: object | undefined): node is LabelledStatement {
     return node instanceof LabelledStatement
 }
-if (!nodeByType.has(44)) {
-    nodeByType.set(44, LabelledStatement)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_LABELLED_STATEMENT)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_LABELLED_STATEMENT, (peer: KNativePointer) => new LabelledStatement(peer))
 }

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

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

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

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

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

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

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

@@ -22,18 +22,21 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { CodeGen } from "./CodeGen"
+import { ETSFunctionType } from "./ETSFunctionType"
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Es2pandaMemberExpressionKind } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { MaybeOptionalExpression } from "./MaybeOptionalExpression"
+import { VReg } from "./VReg"
 export class MemberExpression extends MaybeOptionalExpression {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 45)
         super(pointer)
     }
@@ -43,8 +46,8 @@ export class MemberExpression extends MaybeOptionalExpression {
     static updateMemberExpression(original: MemberExpression | undefined, object_arg: Expression | undefined, property: Expression | undefined, kind: Es2pandaMemberExpressionKind, computed: boolean, optional_arg: boolean): MemberExpression {
         return new MemberExpression(global.generatedEs2panda._UpdateMemberExpression(global.context, passNode(original), passNode(object_arg), passNode(property), kind, computed, optional_arg))
     }
-    get object(): Expression {
-        return unpackNonNullableNode(global.generatedEs2panda._MemberExpressionObjectConst(global.context, this.peer))
+    get object(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._MemberExpressionObject(global.context, this.peer))
     }
     /** @deprecated */
     setObject(object_arg?: Expression): this {
@@ -56,8 +59,8 @@ export class MemberExpression extends MaybeOptionalExpression {
         global.generatedEs2panda._MemberExpressionSetProperty(global.context, this.peer, passNode(prop))
         return this
     }
-    get property(): Expression {
-        return unpackNonNullableNode(global.generatedEs2panda._MemberExpressionPropertyConst(global.context, this.peer))
+    get property(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._MemberExpressionProperty(global.context, this.peer))
     }
     get isComputed(): boolean {
         return global.generatedEs2panda._MemberExpressionIsComputedConst(global.context, this.peer)
@@ -75,6 +78,9 @@ export class MemberExpression extends MaybeOptionalExpression {
         global.generatedEs2panda._MemberExpressionRemoveMemberKind(global.context, this.peer, kind)
         return this
     }
+    get extensionAccessorType(): ETSFunctionType | undefined {
+        return unpackNode(global.generatedEs2panda._MemberExpressionExtensionAccessorTypeConst(global.context, this.peer))
+    }
     get isIgnoreBox(): boolean {
         return global.generatedEs2panda._MemberExpressionIsIgnoreBoxConst(global.context, this.peer)
     }
@@ -86,10 +92,20 @@ export class MemberExpression extends MaybeOptionalExpression {
     get isPrivateReference(): boolean {
         return global.generatedEs2panda._MemberExpressionIsPrivateReferenceConst(global.context, this.peer)
     }
+    /** @deprecated */
+    compileToReg(pg?: CodeGen, objReg?: VReg): this {
+        global.generatedEs2panda._MemberExpressionCompileToRegConst(global.context, this.peer, passNode(pg), passNode(objReg))
+        return this
+    }
+    /** @deprecated */
+    compileToRegs(pg?: CodeGen, object_arg?: VReg, property?: VReg): this {
+        global.generatedEs2panda._MemberExpressionCompileToRegsConst(global.context, this.peer, passNode(pg), passNode(object_arg), passNode(property))
+        return this
+    }
 }
 export function isMemberExpression(node: object | undefined): node is MemberExpression {
     return node instanceof MemberExpression
 }
-if (!nodeByType.has(45)) {
-    nodeByType.set(45, MemberExpression)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_MEMBER_EXPRESSION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_MEMBER_EXPRESSION, (peer: KNativePointer) => new MemberExpression(peer))
 }

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

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

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -30,12 +29,13 @@ import {
 } from "../../reexport-for-generated"
 
 import { ClassElement } from "./ClassElement"
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Es2pandaMethodDefinitionKind } from "./../Es2pandaEnums"
 import { Es2pandaModifierFlags } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { ScriptFunction } from "./ScriptFunction"
 export class MethodDefinition extends ClassElement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 47)
         super(pointer)
     }
@@ -51,17 +51,34 @@ export class MethodDefinition extends ClassElement {
     get isConstructor(): boolean {
         return global.generatedEs2panda._MethodDefinitionIsConstructorConst(global.context, this.peer)
     }
+    get isMethod(): boolean {
+        return global.generatedEs2panda._MethodDefinitionIsMethodConst(global.context, this.peer)
+    }
     get isExtensionMethod(): boolean {
         return global.generatedEs2panda._MethodDefinitionIsExtensionMethodConst(global.context, this.peer)
     }
+    get isGetter(): boolean {
+        return global.generatedEs2panda._MethodDefinitionIsGetterConst(global.context, this.peer)
+    }
+    get isSetter(): boolean {
+        return global.generatedEs2panda._MethodDefinitionIsSetterConst(global.context, this.peer)
+    }
+    get isDefaultAccessModifier(): boolean {
+        return global.generatedEs2panda._MethodDefinitionIsDefaultAccessModifierConst(global.context, this.peer)
+    }
+    /** @deprecated */
+    setDefaultAccessModifier(isDefault: boolean): this {
+        global.generatedEs2panda._MethodDefinitionSetDefaultAccessModifier(global.context, this.peer, isDefault)
+        return this
+    }
     get overloads(): readonly MethodDefinition[] {
         return unpackNodeArray(global.generatedEs2panda._MethodDefinitionOverloadsConst(global.context, this.peer))
     }
     get baseOverloadMethod(): MethodDefinition | undefined {
-        return unpackNode(global.generatedEs2panda._MethodDefinitionBaseOverloadMethodConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._MethodDefinitionBaseOverloadMethod(global.context, this.peer))
     }
     get asyncPairMethod(): MethodDefinition | undefined {
-        return unpackNode(global.generatedEs2panda._MethodDefinitionAsyncPairMethodConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._MethodDefinitionAsyncPairMethod(global.context, this.peer))
     }
     /** @deprecated */
     setOverloads(overloads: readonly MethodDefinition[]): this {
@@ -88,8 +105,8 @@ export class MethodDefinition extends ClassElement {
         global.generatedEs2panda._MethodDefinitionSetAsyncPairMethod(global.context, this.peer, passNode(method))
         return this
     }
-    get function(): ScriptFunction {
-        return unpackNonNullableNode(global.generatedEs2panda._MethodDefinitionFunctionConst(global.context, this.peer))
+    get function(): ScriptFunction | undefined {
+        return unpackNode(global.generatedEs2panda._MethodDefinitionFunction(global.context, this.peer))
     }
     /** @deprecated */
     initializeOverloadInfo(): this {
@@ -100,6 +117,6 @@ export class MethodDefinition extends ClassElement {
 export function isMethodDefinition(node: object | undefined): node is MethodDefinition {
     return node instanceof MethodDefinition
 }
-if (!nodeByType.has(47)) {
-    nodeByType.set(47, MethodDefinition)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION, (peer: KNativePointer) => new MethodDefinition(peer))
 }

package/build/libarkts-copy/src/generated/peers/NamedType.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 { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation"
 import { TypeNode } from "./TypeNode"
 export class NamedType extends TypeNode {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 48)
         super(pointer)
     }
@@ -71,6 +71,6 @@ export class NamedType extends TypeNode {
 export function isNamedType(node: object | undefined): node is NamedType {
     return node instanceof NamedType
 }
-if (!nodeByType.has(48)) {
-    nodeByType.set(48, NamedType)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_NAMED_TYPE)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_NAMED_TYPE, (peer: KNativePointer) => new NamedType(peer))
 }

package/build/libarkts-copy/src/generated/peers/NewExpression.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 NewExpression extends Expression {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 49)
         super(pointer)
     }
@@ -51,6 +51,6 @@ export class NewExpression extends Expression {
 export function isNewExpression(node: object | undefined): node is NewExpression {
     return node instanceof NewExpression
 }
-if (!nodeByType.has(49)) {
-    nodeByType.set(49, NewExpression)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_NEW_EXPRESSION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_NEW_EXPRESSION, (peer: KNativePointer) => new NewExpression(peer))
 }

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

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

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

@@ -22,19 +22,34 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Literal } from "./Literal"
 export class NumberLiteral extends Literal {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 52)
         super(pointer)
     }
+    static createNumberLiteral(value: number): AstNode {
+        return new NumberLiteral(global.generatedEs2panda._CreateNumberLiteral(global.context, value))
+    }
+    static updateNumberLiteral(original: AstNode | undefined, value: number): AstNode {
+        return new NumberLiteral(global.generatedEs2panda._UpdateNumberLiteral(global.context, passNode(original), value))
+    }
+    static update1NumberLiteral(original: AstNode | undefined, value: number): AstNode {
+        return new NumberLiteral(global.generatedEs2panda._UpdateNumberLiteral1(global.context, passNode(original), value))
+    }
+    static update2NumberLiteral(original: AstNode | undefined, value: number): AstNode {
+        return new NumberLiteral(global.generatedEs2panda._UpdateNumberLiteral2(global.context, passNode(original), value))
+    }
+    static update3NumberLiteral(original: AstNode | undefined, value: number): AstNode {
+        return new NumberLiteral(global.generatedEs2panda._UpdateNumberLiteral3(global.context, passNode(original), value))
+    }
     get str(): string {
         return unpackString(global.generatedEs2panda._NumberLiteralStrConst(global.context, this.peer))
     }
@@ -42,6 +57,6 @@ export class NumberLiteral extends Literal {
 export function isNumberLiteral(node: object | undefined): node is NumberLiteral {
     return node instanceof NumberLiteral
 }
-if (!nodeByType.has(52)) {
-    nodeByType.set(52, NumberLiteral)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL, (peer: KNativePointer) => new NumberLiteral(peer))
 }

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

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -31,11 +30,12 @@ import {
 
 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 ObjectExpression extends AnnotatedExpression {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 160)
         super(pointer)
     }
@@ -85,6 +85,6 @@ export class ObjectExpression extends AnnotatedExpression {
 export function isObjectExpression(node: object | undefined): node is ObjectExpression {
     return node instanceof ObjectExpression
 }
-if (!nodeByType.has(160)) {
-    nodeByType.set(160, ObjectExpression)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_OBJECT_EXPRESSION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_OBJECT_EXPRESSION, (peer: KNativePointer) => new ObjectExpression(peer))
 }

package/build/libarkts-copy/src/generated/peers/OmittedExpression.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 OmittedExpression extends Expression {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 53)
         super(pointer)
     }
@@ -45,6 +45,6 @@ export class OmittedExpression extends Expression {
 export function isOmittedExpression(node: object | undefined): node is OmittedExpression {
     return node instanceof OmittedExpression
 }
-if (!nodeByType.has(53)) {
-    nodeByType.set(53, OmittedExpression)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_OMITTED_EXPRESSION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_OMITTED_EXPRESSION, (peer: KNativePointer) => new OmittedExpression(peer))
 }

package/build/libarkts-copy/src/generated/peers/OpaqueTypeNode.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 OpaqueTypeNode extends TypeNode {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 153)
         super(pointer)
     }
@@ -45,6 +45,6 @@ export class OpaqueTypeNode extends TypeNode {
 export function isOpaqueTypeNode(node: object | undefined): node is OpaqueTypeNode {
     return node instanceof OpaqueTypeNode
 }
-if (!nodeByType.has(153)) {
-    nodeByType.set(153, OpaqueTypeNode)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_OPAQUE_TYPE_NODE)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_OPAQUE_TYPE_NODE, (peer: KNativePointer) => new OpaqueTypeNode(peer))
 }

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

package/build/libarkts-copy/src/generated/peers/PrefixAssertionExpression.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 PrefixAssertionExpression extends Expression {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 54)
         super(pointer)
     }
@@ -52,6 +52,6 @@ export class PrefixAssertionExpression extends Expression {
 export function isPrefixAssertionExpression(node: object | undefined): node is PrefixAssertionExpression {
     return node instanceof PrefixAssertionExpression
 }
-if (!nodeByType.has(54)) {
-    nodeByType.set(54, PrefixAssertionExpression)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_PREFIX_ASSERTION_EXPRESSION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_PREFIX_ASSERTION_EXPRESSION, (peer: KNativePointer) => new PrefixAssertionExpression(peer))
 }