@idlizer/arktscgen 2.1.2 → 2.1.7

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

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -31,14 +30,19 @@ import {
 
 import { BlockStatement } from "./BlockStatement"
 import { CatchClause } from "./CatchClause"
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
+import { LabelPair } from "./LabelPair"
 import { Statement } from "./Statement"
 export class TryStatement extends Statement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 146)
         super(pointer)
     }
-    static create1TryStatement(other?: TryStatement): TryStatement {
-        return new TryStatement(global.generatedEs2panda._CreateTryStatement1(global.context, passNode(other)))
+    static createTryStatement(block: BlockStatement | undefined, catchClauses: readonly CatchClause[], finalizer: BlockStatement | undefined, finalizerInsertionsLabelPair: readonly LabelPair[], finalizerInsertionsStatement: readonly Statement[]): TryStatement {
+        return new TryStatement(global.generatedEs2panda._CreateTryStatement(global.context, passNode(block), passNodeArray(catchClauses), catchClauses.length, passNode(finalizer), passNodeArray(finalizerInsertionsLabelPair), finalizerInsertionsLabelPair.length, passNodeArray(finalizerInsertionsStatement), finalizerInsertionsStatement.length))
+    }
+    static updateTryStatement(original: TryStatement | undefined, block: BlockStatement | undefined, catchClauses: readonly CatchClause[], finalizer: BlockStatement | undefined, finalizerInsertionsLabelPair: readonly LabelPair[], finalizerInsertionsStatement: readonly Statement[]): TryStatement {
+        return new TryStatement(global.generatedEs2panda._UpdateTryStatement(global.context, passNode(original), passNode(block), passNodeArray(catchClauses), catchClauses.length, passNode(finalizer), passNodeArray(finalizerInsertionsLabelPair), finalizerInsertionsLabelPair.length, passNodeArray(finalizerInsertionsStatement), finalizerInsertionsStatement.length))
     }
     static update1TryStatement(original?: TryStatement, other?: TryStatement): TryStatement {
         return new TryStatement(global.generatedEs2panda._UpdateTryStatement1(global.context, passNode(original), passNode(other)))
@@ -70,6 +74,6 @@ export class TryStatement extends Statement {
 export function isTryStatement(node: object | undefined): node is TryStatement {
     return node instanceof TryStatement
 }
-if (!nodeByType.has(146)) {
-    nodeByType.set(146, TryStatement)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TRY_STATEMENT)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TRY_STATEMENT, (peer: KNativePointer) => new TryStatement(peer))
 }

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -32,11 +31,11 @@ import {
 import { AnnotationUsage } from "./AnnotationUsage"
 import { Expression } from "./Expression"
 export class TypeNode extends Expression {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         super(pointer)
     }
     get annotations(): readonly AnnotationUsage[] {
-        return unpackNodeArray(global.generatedEs2panda._TypeNodeAnnotationsConst(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._TypeNodeAnnotations(global.context, this.peer))
     }
     /** @deprecated */
     setAnnotations(annotations: readonly AnnotationUsage[]): this {

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -30,7 +29,7 @@ import {
 } from "../../reexport-for-generated"
 
 export class TypedAstNode extends AstNode {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         super(pointer)
     }
 }

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

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

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

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

@@ -22,17 +22,17 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Es2pandaTokenType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 export class UnaryExpression extends Expression {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 147)
         super(pointer)
     }
@@ -46,12 +46,12 @@ export class UnaryExpression extends Expression {
         return global.generatedEs2panda._UnaryExpressionOperatorTypeConst(global.context, this.peer)
     }
     get argument(): Expression | undefined {
-        return unpackNode(global.generatedEs2panda._UnaryExpressionArgumentConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._UnaryExpressionArgument(global.context, this.peer))
     }
 }
 export function isUnaryExpression(node: object | undefined): node is UnaryExpression {
     return node instanceof UnaryExpression
 }
-if (!nodeByType.has(147)) {
-    nodeByType.set(147, UnaryExpression)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_UNARY_EXPRESSION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_UNARY_EXPRESSION, (peer: KNativePointer) => new UnaryExpression(peer))
 }

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

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

@@ -22,17 +22,17 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Es2pandaTokenType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 export class UpdateExpression extends Expression {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 148)
         super(pointer)
     }
@@ -46,7 +46,7 @@ export class UpdateExpression extends Expression {
         return global.generatedEs2panda._UpdateExpressionOperatorTypeConst(global.context, this.peer)
     }
     get argument(): Expression | undefined {
-        return unpackNode(global.generatedEs2panda._UpdateExpressionArgumentConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._UpdateExpressionArgument(global.context, this.peer))
     }
     get isPrefix(): boolean {
         return global.generatedEs2panda._UpdateExpressionIsPrefixConst(global.context, this.peer)
@@ -55,6 +55,6 @@ export class UpdateExpression extends Expression {
 export function isUpdateExpression(node: object | undefined): node is UpdateExpression {
     return node instanceof UpdateExpression
 }
-if (!nodeByType.has(148)) {
-    nodeByType.set(148, UpdateExpression)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_UPDATE_EXPRESSION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_UPDATE_EXPRESSION, (peer: KNativePointer) => new UpdateExpression(peer))
 }

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

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

@@ -22,19 +22,19 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { SourcePosition } from "./SourcePosition"
 export class ValidationInfo extends ArktsObject {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         super(pointer)
     }
-    static createValidationInfo(): ValidationInfo {
-        return new ValidationInfo(global.generatedEs2panda._CreateValidationInfo(global.context))
+    static create1ValidationInfo(m: string, p?: SourcePosition): ValidationInfo {
+        return new ValidationInfo(global.generatedEs2panda._CreateValidationInfo1(global.context, m, passNode(p)))
     }
     get fail(): boolean {
         return global.generatedEs2panda._ValidationInfoFailConst(global.context, this.peer)

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -31,11 +30,12 @@ import {
 
 import { AnnotationUsage } from "./AnnotationUsage"
 import { Decorator } from "./Decorator"
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Es2pandaVariableDeclarationKind } from "./../Es2pandaEnums"
 import { Statement } from "./Statement"
 import { VariableDeclarator } from "./VariableDeclarator"
 export class VariableDeclaration extends Statement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 149)
         super(pointer)
     }
@@ -55,7 +55,7 @@ export class VariableDeclaration extends Statement {
         return unpackNodeArray(global.generatedEs2panda._VariableDeclarationDecoratorsConst(global.context, this.peer))
     }
     get annotations(): readonly AnnotationUsage[] {
-        return unpackNodeArray(global.generatedEs2panda._VariableDeclarationAnnotationsConst(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._VariableDeclarationAnnotations(global.context, this.peer))
     }
     /** @deprecated */
     setAnnotations(annotations: readonly AnnotationUsage[]): this {
@@ -66,6 +66,6 @@ export class VariableDeclaration extends Statement {
 export function isVariableDeclaration(node: object | undefined): node is VariableDeclaration {
     return node instanceof VariableDeclaration
 }
-if (!nodeByType.has(149)) {
-    nodeByType.set(149, VariableDeclaration)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATION, (peer: KNativePointer) => new VariableDeclaration(peer))
 }

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

@@ -22,18 +22,18 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Es2pandaVariableDeclaratorFlag } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { TypedStatement } from "./TypedStatement"
 export class VariableDeclarator extends TypedStatement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 150)
         super(pointer)
     }
@@ -47,15 +47,15 @@ export class VariableDeclarator extends TypedStatement {
         return new VariableDeclarator(global.generatedEs2panda._UpdateVariableDeclarator1(global.context, passNode(original), flag, passNode(ident), passNode(init)))
     }
     get init(): Expression | undefined {
-        return unpackNode(global.generatedEs2panda._VariableDeclaratorInitConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._VariableDeclaratorInit(global.context, this.peer))
     }
     /** @deprecated */
     setInit(init?: Expression): this {
         global.generatedEs2panda._VariableDeclaratorSetInit(global.context, this.peer, passNode(init))
         return this
     }
-    get id(): Expression {
-        return unpackNonNullableNode(global.generatedEs2panda._VariableDeclaratorIdConst(global.context, this.peer))
+    get id(): Expression | undefined {
+        return unpackNode(global.generatedEs2panda._VariableDeclaratorId(global.context, this.peer))
     }
     get flag(): Es2pandaVariableDeclaratorFlag {
         return global.generatedEs2panda._VariableDeclaratorFlag(global.context, this.peer)
@@ -64,6 +64,6 @@ export class VariableDeclarator extends TypedStatement {
 export function isVariableDeclarator(node: object | undefined): node is VariableDeclarator {
     return node instanceof VariableDeclarator
 }
-if (!nodeByType.has(150)) {
-    nodeByType.set(150, VariableDeclarator)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATOR)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATOR, (peer: KNativePointer) => new VariableDeclarator(peer))
 }

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

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

package/build/libarkts-copy/src/generated/peers/WhileStatement.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 WhileStatement extends LoopStatement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 151)
         super(pointer)
     }
@@ -44,15 +44,15 @@ export class WhileStatement extends LoopStatement {
         return new WhileStatement(global.generatedEs2panda._UpdateWhileStatement(global.context, passNode(original), passNode(test), passNode(body)))
     }
     get test(): Expression | undefined {
-        return unpackNode(global.generatedEs2panda._WhileStatementTestConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._WhileStatementTest(global.context, this.peer))
     }
     get body(): Statement | undefined {
-        return unpackNode(global.generatedEs2panda._WhileStatementBodyConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._WhileStatementBody(global.context, this.peer))
     }
 }
 export function isWhileStatement(node: object | undefined): node is WhileStatement {
     return node instanceof WhileStatement
 }
-if (!nodeByType.has(151)) {
-    nodeByType.set(151, WhileStatement)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_WHILE_STATEMENT)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_WHILE_STATEMENT, (peer: KNativePointer) => new WhileStatement(peer))
 }

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

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

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2022-2023 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.
+ */
+
+export * from "./utils"
+export * from "./reexport-for-generated"
+export * from "./generated/Es2pandaEnums"
+export * from "./generated"
+
+export * from "./arkts-api/utilities/private"
+export * from "./arkts-api/utilities/public"
+export * from "./arkts-api/factory/nodeFactory"
+export * from "./arkts-api/visitor"
+export * from "./arkts-api/AbstractVisitor"
+export * from "./arkts-api/CheckedBackFilter"
+export * from "./arkts-api/SetBaseOverloads"
+export * from "./arkts-api/plugins"
+
+export * from "./arkts-api/peers/AstNode"
+export * from "./arkts-api/peers/Config"
+export * from "./arkts-api/peers/Context"
+export * from "./arkts-api/peers/Program"
+export * from "./arkts-api/peers/ImportPathManager"
+export { global as arktsGlobal } from "./arkts-api/static/global"

package/build/libarkts-copy/src/reexport-for-generated.ts

@@ -15,7 +15,7 @@
 export { KNativePointer } from "@koalaui/interop"
 export { AstNode } from "./arkts-api/peers/AstNode"
 export { ArktsObject, isSameNativeObject } from "./arkts-api/peers/ArktsObject"
-export { Es2pandaAstNodeType } from "./Es2pandaEnums"
+export { NodeCache } from "./arkts-api/node-cache"
 export {
     passNode,
     unpackNonNullableNode,

package/build/libarkts-copy/src/ts-api/factory/nodeFactory.ts

@@ -1,3 +1,18 @@
+/*
+ * Copyright (c) 2022-2023 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 { throwError } from "../../utils"
 import * as ts from "@koalaui/ets-tsc"
 import * as arkts from "../../arkts-api"

package/build/libarkts-copy/src/ts-api/factory/nodeTests.ts

@@ -1,3 +1,18 @@
+/*
+ * Copyright (c) 2022-2023 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 { SyntaxKind, } from "@koalaui/ets-tsc"
 
 import {

package/build/libarkts-copy/src/ts-api/types.ts

@@ -1,3 +1,18 @@
+/*
+ * Copyright (c) 2022-2023 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 * as ts from "@koalaui/ets-tsc"
 import * as arkts from "../arkts-api"