@idlizer/arktscgen 2.1.2 → 2.1.5

package/build/libarkts-copy/src/generated/factory.ts

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -42,7 +41,6 @@ import { BlockExpression } from "./peers/BlockExpression"
 import { BlockStatement } from "./peers/BlockStatement"
 import { BooleanLiteral } from "./peers/BooleanLiteral"
 import { BreakStatement } from "./peers/BreakStatement"
-import { CallExpression } from "./peers/CallExpression"
 import { CatchClause } from "./peers/CatchClause"
 import { ChainExpression } from "./peers/ChainExpression"
 import { CharLiteral } from "./peers/CharLiteral"
@@ -55,7 +53,7 @@ import { DebuggerStatement } from "./peers/DebuggerStatement"
 import { Decorator } from "./peers/Decorator"
 import { DoWhileStatement } from "./peers/DoWhileStatement"
 import { ETSClassLiteral } from "./peers/ETSClassLiteral"
-import { ETSLaunchExpression } from "./peers/ETSLaunchExpression"
+import { ETSKeyofType } from "./peers/ETSKeyofType"
 import { ETSNewArrayInstanceExpression } from "./peers/ETSNewArrayInstanceExpression"
 import { ETSNewClassInstanceExpression } from "./peers/ETSNewClassInstanceExpression"
 import { ETSNewMultiDimArrayInstanceExpression } from "./peers/ETSNewMultiDimArrayInstanceExpression"
@@ -87,7 +85,6 @@ import { IfStatement } from "./peers/IfStatement"
 import { ImportDefaultSpecifier } from "./peers/ImportDefaultSpecifier"
 import { ImportExpression } from "./peers/ImportExpression"
 import { ImportNamespaceSpecifier } from "./peers/ImportNamespaceSpecifier"
-import { ImportSource } from "./peers/ImportSource"
 import { ImportSpecifier } from "./peers/ImportSpecifier"
 import { LabelledStatement } from "./peers/LabelledStatement"
 import { MetaProperty } from "./peers/MetaProperty"
@@ -158,7 +155,6 @@ import { TypeofExpression } from "./peers/TypeofExpression"
 import { UnaryExpression } from "./peers/UnaryExpression"
 import { UndefinedLiteral } from "./peers/UndefinedLiteral"
 import { UpdateExpression } from "./peers/UpdateExpression"
-import { ValidationInfo } from "./peers/ValidationInfo"
 import { VariableDeclaration } from "./peers/VariableDeclaration"
 import { VariableDeclarator } from "./peers/VariableDeclarator"
 import { WhileStatement } from "./peers/WhileStatement"
@@ -192,11 +188,11 @@ export const factory = {
         return updateNodeByNode(TSVoidKeyword.createTSVoidKeyword(), original)
     }
     ,
-    createIfStatement(test: Expression, consequent: Statement, alternate?: Statement): IfStatement {
+    createIfStatement(test?: Expression, consequent?: Statement, alternate?: Statement): IfStatement {
         return IfStatement.createIfStatement(test, consequent, alternate)
     }
     ,
-    updateIfStatement(original: IfStatement, test: Expression, consequent: Statement, alternate?: Statement): IfStatement {
+    updateIfStatement(original: IfStatement, test?: Expression, consequent?: Statement, alternate?: Statement): IfStatement {
         if (isSameNativeObject(test, original.test) && isSameNativeObject(consequent, original.consequent) && isSameNativeObject(alternate, original.alternate))
             return original
         return updateNodeByNode(IfStatement.createIfStatement(test, consequent, alternate), original)
@@ -280,11 +276,11 @@ export const factory = {
         return updateNodeByNode(TaggedTemplateExpression.createTaggedTemplateExpression(tag, quasi, typeParams), original)
     }
     ,
-    createFunctionDeclaration(_function: ScriptFunction, annotations: readonly AnnotationUsage[], isAnonymous: boolean): FunctionDeclaration {
+    createFunctionDeclaration(_function: ScriptFunction | undefined, annotations: readonly AnnotationUsage[], isAnonymous: boolean): FunctionDeclaration {
         return FunctionDeclaration.createFunctionDeclaration(_function, annotations, isAnonymous)
     }
     ,
-    updateFunctionDeclaration(original: FunctionDeclaration, _function: ScriptFunction, annotations: readonly AnnotationUsage[], isAnonymous: boolean): FunctionDeclaration {
+    updateFunctionDeclaration(original: FunctionDeclaration, _function: ScriptFunction | undefined, annotations: readonly AnnotationUsage[], isAnonymous: boolean): FunctionDeclaration {
         if (isSameNativeObject(_function, original.function) && isSameNativeObject(annotations, original.annotations) && isSameNativeObject(isAnonymous, original.isAnonymous))
             return original
         return updateNodeByNode(FunctionDeclaration.createFunctionDeclaration(_function, annotations, isAnonymous), original)
@@ -310,16 +306,6 @@ export const factory = {
         return updateNodeByNode(TSTypeReference.createTSTypeReference(typeName, typeParams), original)
     }
     ,
-    createImportSource(source: StringLiteral | undefined, resolvedSource: StringLiteral | undefined, hasDecl: boolean): ImportSource {
-        return ImportSource.createImportSource(source, resolvedSource, hasDecl)
-    }
-    ,
-    updateImportSource(original: ImportSource, source: StringLiteral | undefined, resolvedSource: StringLiteral | undefined, hasDecl: boolean): ImportSource {
-        if (isSameNativeObject(source, original.source) && isSameNativeObject(resolvedSource, original.resolvedSource) && isSameNativeObject(hasDecl, original.hasDecl))
-            return original
-        return updateNodeByNode(ImportSource.createImportSource(source, resolvedSource, hasDecl), original)
-    }
-    ,
     createNamedType(name?: Identifier): NamedType {
         return NamedType.createNamedType(name)
     }
@@ -386,6 +372,16 @@ export const factory = {
         return updateNodeByNode(ETSUnionType.createETSUnionType(types), original)
     }
     ,
+    createETSKeyofType(typeRef?: TypeNode): ETSKeyofType {
+        return ETSKeyofType.createETSKeyofType(typeRef)
+    }
+    ,
+    updateETSKeyofType(original: ETSKeyofType, typeRef?: TypeNode): ETSKeyofType {
+        if (isSameNativeObject(typeRef, original.typeRef))
+            return original
+        return updateNodeByNode(ETSKeyofType.createETSKeyofType(typeRef), original)
+    }
+    ,
     createTSConditionalType(checkType?: Expression, extendsType?: Expression, trueType?: Expression, falseType?: Expression): TSConditionalType {
         return TSConditionalType.createTSConditionalType(checkType, extendsType, trueType, falseType)
     }
@@ -406,11 +402,11 @@ export const factory = {
         return updateNodeByNode(TSLiteralType.createTSLiteralType(literal), original)
     }
     ,
-    createTSTypeAliasDeclaration(id?: Identifier, typeParams?: TSTypeParameterDeclaration, typeAnnotation?: TypeNode): TSTypeAliasDeclaration {
+    createTSTypeAliasDeclaration(id: Identifier | undefined, typeParams: TSTypeParameterDeclaration | undefined, typeAnnotation: TypeNode): TSTypeAliasDeclaration {
         return TSTypeAliasDeclaration.createTSTypeAliasDeclaration(id, typeParams, typeAnnotation)
     }
     ,
-    updateTSTypeAliasDeclaration(original: TSTypeAliasDeclaration, id?: Identifier, typeParams?: TSTypeParameterDeclaration, typeAnnotation?: TypeNode): TSTypeAliasDeclaration {
+    updateTSTypeAliasDeclaration(original: TSTypeAliasDeclaration, id: Identifier | undefined, typeParams: TSTypeParameterDeclaration | undefined, typeAnnotation: TypeNode): TSTypeAliasDeclaration {
         if (isSameNativeObject(id, original.id) && isSameNativeObject(typeParams, original.typeParams) && isSameNativeObject(typeAnnotation, original.typeAnnotation))
             return original
         return updateNodeByNode(TSTypeAliasDeclaration.createTSTypeAliasDeclaration(id, typeParams, typeAnnotation), original)
@@ -584,11 +580,11 @@ export const factory = {
         return updateNodeByNode(TSStringKeyword.createTSStringKeyword(), original)
     }
     ,
-    createExpressionStatement(expression: Expression): ExpressionStatement {
+    createExpressionStatement(expression?: Expression): ExpressionStatement {
         return ExpressionStatement.createExpressionStatement(expression)
     }
     ,
-    updateExpressionStatement(original: ExpressionStatement, expression: Expression): ExpressionStatement {
+    updateExpressionStatement(original: ExpressionStatement, expression?: Expression): ExpressionStatement {
         if (isSameNativeObject(expression, original.expression))
             return original
         return updateNodeByNode(ExpressionStatement.createExpressionStatement(expression), original)
@@ -720,16 +716,6 @@ export const factory = {
         return updateNodeByNode(EmptyStatement.createEmptyStatement(), original)
     }
     ,
-    createETSLaunchExpression(call?: CallExpression): ETSLaunchExpression {
-        return ETSLaunchExpression.createETSLaunchExpression(call)
-    }
-    ,
-    updateETSLaunchExpression(original: ETSLaunchExpression, call?: CallExpression): ETSLaunchExpression {
-        if (isSameNativeObject(call, original.call))
-            return original
-        return updateNodeByNode(ETSLaunchExpression.createETSLaunchExpression(call), original)
-    }
-    ,
     createWhileStatement(test?: Expression, body?: Statement): WhileStatement {
         return WhileStatement.createWhileStatement(test, body)
     }
@@ -1096,14 +1082,6 @@ export const factory = {
         return updateNodeByNode(AwaitExpression.createAwaitExpression(argument), original)
     }
     ,
-    createValidationInfo(): ValidationInfo {
-        return ValidationInfo.createValidationInfo()
-    }
-    ,
-    updateValidationInfo(original: ValidationInfo): ValidationInfo {
-        return updateNodeByNode(ValidationInfo.createValidationInfo(), original)
-    }
-    ,
     createContinueStatement(ident?: Identifier): ContinueStatement {
         return ContinueStatement.create1ContinueStatement(ident)
     }
@@ -1220,11 +1198,11 @@ export const factory = {
         return updateNodeByNode(SequenceExpression.createSequenceExpression(sequence), original)
     }
     ,
-    createArrowFunctionExpression(_function: ScriptFunction): ArrowFunctionExpression {
+    createArrowFunctionExpression(_function?: ScriptFunction): ArrowFunctionExpression {
         return ArrowFunctionExpression.createArrowFunctionExpression(_function)
     }
     ,
-    updateArrowFunctionExpression(original: ArrowFunctionExpression, _function: ScriptFunction): ArrowFunctionExpression {
+    updateArrowFunctionExpression(original: ArrowFunctionExpression, _function?: ScriptFunction): ArrowFunctionExpression {
         if (isSameNativeObject(_function, original.function))
             return original
         return updateNodeByNode(ArrowFunctionExpression.createArrowFunctionExpression(_function), original)

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

@@ -13,6 +13,28 @@
  * limitations under the License.
  */
 
+export * from "./peers/SourcePosition"
+export * from "./peers/SourceRange"
+export * from "./peers/LabelPair"
+export * from "./peers/ScriptFunctionData"
+export * from "./peers/ImportSource"
+export * from "./peers/SignatureInfo"
+export * from "./peers/IndexInfo"
+export * from "./peers/ObjectDescriptor"
+export * from "./peers/ScopeFindResult"
+export * from "./peers/BindingProps"
+export * from "./peers/Declaration"
+export * from "./peers/AstVisitor"
+export * from "./peers/AstVerifier"
+export * from "./peers/VerifierMessage"
+export * from "./peers/CodeGen"
+export * from "./peers/VReg"
+export * from "./peers/IRNode"
+export * from "./peers/ErrorLogger"
+export * from "./peers/VerificationContext"
+export * from "./peers/DynamicImportData"
+export * from "./peers/OverloadInfo"
+export * from "./peers/NumberLiteral"
 export * from "./peers/TypedAstNode"
 export * from "./peers/AnnotatedAstNode"
 export * from "./peers/TypedStatement"
@@ -40,9 +62,7 @@ export * from "./peers/TaggedTemplateExpression"
 export * from "./peers/FunctionDeclaration"
 export * from "./peers/ETSTypeReference"
 export * from "./peers/TSTypeReference"
-export * from "./peers/ImportSource"
 export * from "./peers/NamedType"
-export * from "./peers/NumberLiteral"
 export * from "./peers/TSFunctionType"
 export * from "./peers/TemplateElement"
 export * from "./peers/TSInterfaceDeclaration"
@@ -52,6 +72,7 @@ export * from "./peers/MemberExpression"
 export * from "./peers/TSClassImplements"
 export * from "./peers/TSObjectKeyword"
 export * from "./peers/ETSUnionType"
+export * from "./peers/ETSKeyofType"
 export * from "./peers/TSPropertySignature"
 export * from "./peers/TSConditionalType"
 export * from "./peers/TSLiteralType"
@@ -72,6 +93,7 @@ export * from "./peers/TSTypeAssertion"
 export * from "./peers/TSExternalModuleReference"
 export * from "./peers/TSUndefinedKeyword"
 export * from "./peers/ETSTuple"
+export * from "./peers/ETSStringLiteralType"
 export * from "./peers/TryStatement"
 export * from "./peers/UnaryExpression"
 export * from "./peers/ForInStatement"
@@ -106,7 +128,6 @@ export * from "./peers/LoopStatement"
 export * from "./peers/AnnotationDeclaration"
 export * from "./peers/AnnotationUsage"
 export * from "./peers/EmptyStatement"
-export * from "./peers/ETSLaunchExpression"
 export * from "./peers/WhileStatement"
 export * from "./peers/FunctionSignature"
 export * from "./peers/ChainExpression"

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

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

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -32,7 +31,7 @@ import {
 import { Expression } from "./Expression"
 import { TypeNode } from "./TypeNode"
 export class AnnotatedExpression extends Expression {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         super(pointer)
     }
     get typeAnnotation(): TypeNode | undefined {

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

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

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -30,11 +29,12 @@ import {
 } from "../../reexport-for-generated"
 
 import { AnnotationUsage } from "./AnnotationUsage"
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { Identifier } from "./Identifier"
 import { Statement } from "./Statement"
 export class AnnotationDeclaration extends Statement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 1)
         super(pointer)
     }
@@ -56,10 +56,10 @@ export class AnnotationDeclaration extends Statement {
         return this
     }
     get expr(): Expression | undefined {
-        return unpackNode(global.generatedEs2panda._AnnotationDeclarationExprConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._AnnotationDeclarationExpr(global.context, this.peer))
     }
     get properties(): readonly AstNode[] {
-        return unpackNodeArray(global.generatedEs2panda._AnnotationDeclarationPropertiesConst(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._AnnotationDeclarationProperties(global.context, this.peer))
     }
     /** @deprecated */
     addProperties(properties: readonly AstNode[]): this {
@@ -94,7 +94,7 @@ export class AnnotationDeclaration extends Statement {
         return unpackNode(global.generatedEs2panda._AnnotationDeclarationGetBaseNameConst(global.context, this.peer))
     }
     get annotations(): readonly AnnotationUsage[] {
-        return unpackNodeArray(global.generatedEs2panda._AnnotationDeclarationAnnotationsConst(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._AnnotationDeclarationAnnotations(global.context, this.peer))
     }
     /** @deprecated */
     setAnnotations(annotations: readonly AnnotationUsage[]): this {
@@ -105,6 +105,6 @@ export class AnnotationDeclaration extends Statement {
 export function isAnnotationDeclaration(node: object | undefined): node is AnnotationDeclaration {
     return node instanceof AnnotationDeclaration
 }
-if (!nodeByType.has(1)) {
-    nodeByType.set(1, AnnotationDeclaration)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_DECLARATION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_DECLARATION, (peer: KNativePointer) => new AnnotationDeclaration(peer))
 }

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

@@ -22,53 +22,53 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { Identifier } from "./Identifier"
 import { Statement } from "./Statement"
 export class AnnotationUsage extends Statement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 2)
         super(pointer)
     }
     static create1AnnotationUsage(expr: Expression | undefined, properties: readonly AstNode[]): AnnotationUsage {
-        return new AnnotationUsage(global.generatedEs2panda._CreateAnnotationUsageIr1(global.context, passNode(expr), passNodeArray(properties), properties.length))
+        return new AnnotationUsage(global.generatedEs2panda._CreateAnnotationUsage1(global.context, passNode(expr), passNodeArray(properties), properties.length))
     }
     static updateAnnotationUsage(original?: AnnotationUsage, expr?: Expression): AnnotationUsage {
-        return new AnnotationUsage(global.generatedEs2panda._UpdateAnnotationUsageIr(global.context, passNode(original), passNode(expr)))
+        return new AnnotationUsage(global.generatedEs2panda._UpdateAnnotationUsage(global.context, passNode(original), passNode(expr)))
     }
     static update1AnnotationUsage(original: AnnotationUsage | undefined, expr: Expression | undefined, properties: readonly AstNode[]): AnnotationUsage {
-        return new AnnotationUsage(global.generatedEs2panda._UpdateAnnotationUsageIr1(global.context, passNode(original), passNode(expr), passNodeArray(properties), properties.length))
+        return new AnnotationUsage(global.generatedEs2panda._UpdateAnnotationUsage1(global.context, passNode(original), passNode(expr), passNodeArray(properties), properties.length))
     }
     get expr(): Expression | undefined {
-        return unpackNode(global.generatedEs2panda._AnnotationUsageIrExpr(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._AnnotationUsageExpr(global.context, this.peer))
     }
     get properties(): readonly AstNode[] {
-        return unpackNodeArray(global.generatedEs2panda._AnnotationUsageIrPropertiesConst(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._AnnotationUsageProperties(global.context, this.peer))
     }
     /** @deprecated */
     addProperty(property?: AstNode): this {
-        global.generatedEs2panda._AnnotationUsageIrAddProperty(global.context, this.peer, passNode(property))
+        global.generatedEs2panda._AnnotationUsageAddProperty(global.context, this.peer, passNode(property))
         return this
     }
     /** @deprecated */
     setProperties(properties: readonly AstNode[]): this {
-        global.generatedEs2panda._AnnotationUsageIrSetProperties(global.context, this.peer, passNodeArray(properties), properties.length)
+        global.generatedEs2panda._AnnotationUsageSetProperties(global.context, this.peer, passNodeArray(properties), properties.length)
         return this
     }
     get baseName(): Identifier | undefined {
-        return unpackNode(global.generatedEs2panda._AnnotationUsageIrGetBaseNameConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._AnnotationUsageGetBaseNameConst(global.context, this.peer))
     }
 }
 export function isAnnotationUsage(node: object | undefined): node is AnnotationUsage {
     return node instanceof AnnotationUsage
 }
-if (!nodeByType.has(2)) {
-    nodeByType.set(2, AnnotationUsage)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE, (peer: KNativePointer) => new AnnotationUsage(peer))
 }

package/build/libarkts-copy/src/generated/peers/ArrayExpression.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 ArrayExpression extends AnnotatedExpression {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 156)
         super(pointer)
     }
@@ -49,7 +49,7 @@ export class ArrayExpression extends AnnotatedExpression {
         return new ArrayExpression(global.generatedEs2panda._UpdateArrayExpression1(global.context, passNode(original), nodeType, passNodeArray(elements), elements.length, trailingComma))
     }
     get elements(): readonly Expression[] {
-        return unpackNodeArray(global.generatedEs2panda._ArrayExpressionElementsConst(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._ArrayExpressionElements(global.context, this.peer))
     }
     /** @deprecated */
     setElements(elements: readonly Expression[]): this {
@@ -75,6 +75,11 @@ export class ArrayExpression extends AnnotatedExpression {
     get decorators(): readonly Decorator[] {
         return unpackNodeArray(global.generatedEs2panda._ArrayExpressionDecoratorsConst(global.context, this.peer))
     }
+    /** @deprecated */
+    clearPreferredType(): this {
+        global.generatedEs2panda._ArrayExpressionClearPreferredType(global.context, this.peer)
+        return this
+    }
     get convertibleToArrayPattern(): boolean {
         return global.generatedEs2panda._ArrayExpressionConvertibleToArrayPattern(global.context, this.peer)
     }
@@ -93,6 +98,6 @@ export class ArrayExpression extends AnnotatedExpression {
 export function isArrayExpression(node: object | undefined): node is ArrayExpression {
     return node instanceof ArrayExpression
 }
-if (!nodeByType.has(156)) {
-    nodeByType.set(156, ArrayExpression)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ARRAY_EXPRESSION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ARRAY_EXPRESSION, (peer: KNativePointer) => new ArrayExpression(peer))
 }

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -30,11 +29,12 @@ import {
 } from "../../reexport-for-generated"
 
 import { AnnotationUsage } from "./AnnotationUsage"
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 import { ScriptFunction } from "./ScriptFunction"
 import { TypeNode } from "./TypeNode"
 export class ArrowFunctionExpression extends Expression {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 0)
         super(pointer)
     }
@@ -47,14 +47,14 @@ export class ArrowFunctionExpression extends Expression {
     static update1ArrowFunctionExpression(original?: ArrowFunctionExpression, other?: ArrowFunctionExpression): ArrowFunctionExpression {
         return new ArrowFunctionExpression(global.generatedEs2panda._UpdateArrowFunctionExpression1(global.context, passNode(original), passNode(other)))
     }
-    get function(): ScriptFunction {
-        return unpackNonNullableNode(global.generatedEs2panda._ArrowFunctionExpressionFunctionConst(global.context, this.peer))
+    get function(): ScriptFunction | undefined {
+        return unpackNode(global.generatedEs2panda._ArrowFunctionExpressionFunction(global.context, this.peer))
     }
     get createTypeAnnotation(): TypeNode | undefined {
         return unpackNode(global.generatedEs2panda._ArrowFunctionExpressionCreateTypeAnnotation(global.context, this.peer))
     }
     get annotations(): readonly AnnotationUsage[] {
-        return unpackNodeArray(global.generatedEs2panda._ArrowFunctionExpressionAnnotationsConst(global.context, this.peer))
+        return unpackNodeArray(global.generatedEs2panda._ArrowFunctionExpressionAnnotations(global.context, this.peer))
     }
     /** @deprecated */
     setAnnotations(annotations: readonly AnnotationUsage[]): this {
@@ -65,6 +65,6 @@ export class ArrowFunctionExpression extends Expression {
 export function isArrowFunctionExpression(node: object | undefined): node is ArrowFunctionExpression {
     return node instanceof ArrowFunctionExpression
 }
-if (!nodeByType.has(0)) {
-    nodeByType.set(0, ArrowFunctionExpression)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION, (peer: KNativePointer) => new ArrowFunctionExpression(peer))
 }

package/build/libarkts-copy/src/generated/peers/AssertStatement.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 AssertStatement extends Statement {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 3)
         super(pointer)
     }
@@ -43,7 +43,7 @@ export class AssertStatement extends Statement {
         return new AssertStatement(global.generatedEs2panda._UpdateAssertStatement(global.context, passNode(original), passNode(test), passNode(second)))
     }
     get test(): Expression | undefined {
-        return unpackNode(global.generatedEs2panda._AssertStatementTestConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._AssertStatementTest(global.context, this.peer))
     }
     get second(): Expression | undefined {
         return unpackNode(global.generatedEs2panda._AssertStatementSecondConst(global.context, this.peer))
@@ -52,6 +52,6 @@ export class AssertStatement extends Statement {
 export function isAssertStatement(node: object | undefined): node is AssertStatement {
     return node instanceof AssertStatement
 }
-if (!nodeByType.has(3)) {
-    nodeByType.set(3, AssertStatement)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ASSERT_STATEMENT)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ASSERT_STATEMENT, (peer: KNativePointer) => new AssertStatement(peer))
 }

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

@@ -22,17 +22,18 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
     unpackString
 } from "../../reexport-for-generated"
 
+import { CodeGen } from "./CodeGen"
+import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Es2pandaTokenType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 export class AssignmentExpression extends Expression {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         assertValidPeer(pointer, 158)
         super(pointer)
     }
@@ -46,10 +47,10 @@ export class AssignmentExpression extends Expression {
         return new AssignmentExpression(global.generatedEs2panda._UpdateAssignmentExpression1(global.context, passNode(original), type, passNode(left), passNode(right), assignmentOperator))
     }
     get left(): Expression | undefined {
-        return unpackNode(global.generatedEs2panda._AssignmentExpressionLeftConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._AssignmentExpressionLeft(global.context, this.peer))
     }
     get right(): Expression | undefined {
-        return unpackNode(global.generatedEs2panda._AssignmentExpressionRightConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._AssignmentExpressionRight(global.context, this.peer))
     }
     /** @deprecated */
     setRight(expr?: Expression): this {
@@ -62,7 +63,7 @@ export class AssignmentExpression extends Expression {
         return this
     }
     get result(): Expression | undefined {
-        return unpackNode(global.generatedEs2panda._AssignmentExpressionResultConst(global.context, this.peer))
+        return unpackNode(global.generatedEs2panda._AssignmentExpressionResult(global.context, this.peer))
     }
     get operatorType(): Es2pandaTokenType {
         return global.generatedEs2panda._AssignmentExpressionOperatorTypeConst(global.context, this.peer)
@@ -86,10 +87,15 @@ export class AssignmentExpression extends Expression {
     get convertibleToAssignmentPatternRight(): boolean {
         return global.generatedEs2panda._AssignmentExpressionConvertibleToAssignmentPatternRight(global.context, this.peer)
     }
+    /** @deprecated */
+    compilePattern(pg?: CodeGen): this {
+        global.generatedEs2panda._AssignmentExpressionCompilePatternConst(global.context, this.peer, passNode(pg))
+        return this
+    }
 }
 export function isAssignmentExpression(node: object | undefined): node is AssignmentExpression {
     return node instanceof AssignmentExpression
 }
-if (!nodeByType.has(158)) {
-    nodeByType.set(158, AssignmentExpression)
+if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ASSIGNMENT_EXPRESSION)) {
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ASSIGNMENT_EXPRESSION, (peer: KNativePointer) => new AssignmentExpression(peer))
 }

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

@@ -22,7 +22,6 @@ import {
     unpackNodeArray,
     assertValidPeer,
     AstNode,
-    Es2pandaAstNodeType,
     KNativePointer,
     nodeByType,
     ArktsObject,
@@ -30,7 +29,7 @@ import {
 } from "../../reexport-for-generated"
 
 export class AstDumper extends ArktsObject {
-     constructor(pointer: KNativePointer) {
+    constructor(pointer: KNativePointer) {
         super(pointer)
     }
     static createAstDumper(node: AstNode | undefined, sourceCode: string): AstDumper {

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