diff --git a/arkoala-arkts/arkui/src/sts/arkui.after.check.sts b/arkoala-arkts/arkui/src/sts/arkui.after.check.sts
new file mode 100644
index 0000000000000000000000000000000000000000..58b510fa3562f3bda799cd10033fa6385d97dab4
--- /dev/null
+++ b/arkoala-arkts/arkui/src/sts/arkui.after.check.sts
@@ -0,0 +1,117 @@
+// Annotations
+
+export @interface BuilderLambda {
+    value: string
+}
+
+export @interface Component {}
+
+export @interface State {}
+
+export @interface memo {}
+
+export abstract class StructBase<T, OptionsT> {
+
+    static instantiateImpl<S extends StructBase<S, OptionsS>, OptionsS>(
+        builder: ((instance: S)=>S)|undefined,
+        factory: () => S,
+        options?: OptionsS,
+        content?: () => void
+    ) {
+        console.log("Struct instantiate redirected")
+        const instance = factory()
+        if (builder !== undefined) builder(instance)
+        instance._build(builder, content, options)
+    }
+    build() {
+        throw new Error("The struct build() should never be executed directly")
+    }
+
+    protected _build(style: ((instance: T)=>T)|undefined, content: (() => void)|undefined, options: OptionsT|undefined) {
+        throw new Error("The struct _build() must have a valid override")
+    }
+}
+
+export enum Color {
+    White,
+    Red
+}
+
+export interface ColumnOptions {
+    space: number
+}
+
+export class CommonMethod {
+    onClick(callback: () => void): this {
+        console.log("registered Button.onClick()")
+        return this
+    }
+    width(value: number): this {
+        console.log(`.width(${value})`)
+        return this
+    }
+    height(value: number): this {
+        console.log(`.height(${value})`)
+        return this
+    }
+}
+
+// An attempt to put down a component
+export class Column extends CommonMethod {
+
+    static instantiateImpl(
+        style: (instance: Column) => Column,
+        factory: () => Column,
+        options: ColumnOptions,
+        content: () => void
+    ): void {
+        console.log("Column({space:", options.space, "})")
+        const instance = factory()
+        style(instance)
+        content()
+    }
+}
+
+
+export interface ButtonOptions {}
+
+// An attempt to put down a component
+export class Button extends CommonMethod {
+
+    static instantiateImpl(
+        style: (instance: Button) => Button,
+        factory: () => Button,
+        options?: ButtonOptions|string,
+        //content?: () => void
+    ): void {
+        console.log("Button(", options,  ")")
+        const instance = factory()
+        style(instance)
+        //content()
+
+    }
+}
+
+export interface TextOptions {}
+
+// An attempt to put down a component
+export class Text extends CommonMethod {
+
+    // TODO: the second argument will be gone after hte plugin is improved
+    static instantiateImpl(
+        style: (instance: Text) => Text,
+        factory: () => Text,
+        options?: TextOptions|string,
+        //content?: () => void
+    ): void {
+        console.log("Text(", options,  ")")
+        const instance = factory()
+        style(instance)
+        //content()
+    }
+
+    fontColor(value: Color): this {
+        console.log("\.fontColor(", Color[value], ")")
+        return this
+    }
+}
diff --git a/arkoala-arkts/arkui/src/sts/arkui.sts b/arkoala-arkts/arkui/src/sts/arkui.sts
index 69aa97eceb68694645131f7c72d189853e4f7c1e..58b510fa3562f3bda799cd10033fa6385d97dab4 100644
--- a/arkoala-arkts/arkui/src/sts/arkui.sts
+++ b/arkoala-arkts/arkui/src/sts/arkui.sts
@@ -11,14 +11,6 @@ export @interface State {}
 export @interface memo {}
 
 export abstract class StructBase<T, OptionsT> {
-    @BuilderLambda("instantiateImpl")
-    static $_instantiate<S extends StructBase<S, OptionsS>, OptionsS> (
-        factory: () => S,
-        options?: OptionsS,
-        content?: () => void
-    ): S {
-        throw new Error("This method should only be called through a @BuilderLambda redirect")
-    }
 
     static instantiateImpl<S extends StructBase<S, OptionsS>, OptionsS>(
         builder: ((instance: S)=>S)|undefined,
@@ -29,9 +21,15 @@ export abstract class StructBase<T, OptionsT> {
         console.log("Struct instantiate redirected")
         const instance = factory()
         if (builder !== undefined) builder(instance)
-        instance.build()
+        instance._build(builder, content, options)
+    }
+    build() {
+        throw new Error("The struct build() should never be executed directly")
+    }
+
+    protected _build(style: ((instance: T)=>T)|undefined, content: (() => void)|undefined, options: OptionsT|undefined) {
+        throw new Error("The struct _build() must have a valid override")
     }
-    abstract build()
 }
 
 export enum Color {
@@ -60,14 +58,6 @@ export class CommonMethod {
 
 // An attempt to put down a component
 export class Column extends CommonMethod {
-    @BuilderLambda("instantiateImpl")
-    static $_instantiate(
-        factory: () => Column,
-        options: ColumnOptions,
-        content: () => void
-    ): Column {
-        throw new Error("This method should only be called through a @BuilderLambda redirect")
-    }
 
     static instantiateImpl(
         style: (instance: Column) => Column,
@@ -87,17 +77,6 @@ export interface ButtonOptions {}
 
 // An attempt to put down a component
 export class Button extends CommonMethod {
-    // TODO: the second argument will be gone after hte plugin is improved
-    @BuilderLambda("instantiateImpl")
-    static $_instantiate(
-        factory: () => Button,
-        options?: ButtonOptions|string,
-        //content?: () => void
-    ): Button {
-        //throw new Error("This method should only be called through a @BuilderLambda redirect")
-        console.log("Button")
-        return factory()
-    }
 
     static instantiateImpl(
         style: (instance: Button) => Button,
@@ -117,17 +96,6 @@ export interface TextOptions {}
 
 // An attempt to put down a component
 export class Text extends CommonMethod {
-    @BuilderLambda("instantiateImpl")
-    static $_instantiate(
-        factory: () => Text,
-        options?: TextOptions|string,
-        //content?: () => void
-    ): Text {
-        //throw new Error("This method should only be called through a @BuilderLambda redirect")
-
-        console.log("Text")
-        return factory()
-    }
 
     // TODO: the second argument will be gone after hte plugin is improved
     static instantiateImpl(
@@ -141,7 +109,7 @@ export class Text extends CommonMethod {
         style(instance)
         //content()
     }
-    
+
     fontColor(value: Color): this {
         console.log("\.fontColor(", Color[value], ")")
         return this
diff --git a/arkoala-arkts/libarkts/arktsconfig.json b/arkoala-arkts/libarkts/arktsconfig.json
index 85e9e51f6d825c201ca549ce35952deed24d1685..7772457f1933c084f20d111e7ed265f1b9277f01 100644
--- a/arkoala-arkts/libarkts/arktsconfig.json
+++ b/arkoala-arkts/libarkts/arktsconfig.json
@@ -2,6 +2,17 @@
     "compilerOptions": {
         "outDir": "./abc",
         "baseUrl": ".",
+        "paths": {
+            "@koalaui/runtime": [
+                "../memo-plugin/runtime-api"
+            ],
+            "@koalaui/compat": [
+                "../../incremental/compat/src/arkts"
+            ],
+            "@koalaui/common": [
+                "../../incremental/common/src"
+            ]
+        },
         "plugins": [
             {
                 "transform": "./plugins/build/src/printer-plugin.js",
@@ -10,7 +21,7 @@
             {
                 "transform": "./plugins/build/src/parsed-stage-plugin.js",
                 "stage": "parsed",
-                "arkui": "../../../arkui/src/sts"
+                "arkui": "../../../arkui/src/sts/arkui.sts"
 
             },
             {
diff --git a/arkoala-arkts/libarkts/native/src/bridges.cc b/arkoala-arkts/libarkts/native/src/bridges.cc
index 4250b79081d434b8ff41d507e66f64c13be0c7a6..b9e088b9c12477dee075db3e602c6385b4388a19 100644
--- a/arkoala-arkts/libarkts/native/src/bridges.cc
+++ b/arkoala-arkts/libarkts/native/src/bridges.cc
@@ -50,6 +50,15 @@ KNativePointer impl_AnnotationAllowedAnnotations(KNativePointer contextPtr, KNat
 }
 KOALA_INTEROP_3(AnnotationAllowedAnnotations, KNativePointer, KNativePointer, KNativePointer, KNativePointer)
 
+KNativePointer impl_AnnotationAllowedAnnotationsConst(KNativePointer contextPtr, KNativePointer nodePtr, KNativePointer returnLen) {
+    auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+    auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+    std::size_t params_len = 0;
+    auto annotations = GetImpl()->AnnotationAllowedAnnotationsConst(context, node, &params_len);
+    return new std::vector<void*>(annotations, annotations + params_len);
+}
+KOALA_INTEROP_3(AnnotationAllowedAnnotationsConst, KNativePointer, KNativePointer, KNativePointer, KNativePointer)
+
 KNativePointer impl_AstNodeVariableConst(KNativePointer contextPtr, KNativePointer nodePtr) {
     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
@@ -275,3 +284,9 @@ KNativePointer impl_DeclarationFromIdentifier(KNativePointer context, KNativePoi
     return result;
 }
 KOALA_INTEROP_2(DeclarationFromIdentifier, KNativePointer, KNativePointer, KNativePointer)
+
+KBoolean impl_IsETSImportDeclaration(KNativePointer nodePtr) {
+    auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+    return GetImpl()->IsETSImportDeclaration(node);
+}
+KOALA_INTEROP_1(IsETSImportDeclaration, KBoolean, KNativePointer)
\ No newline at end of file
diff --git a/arkoala-arkts/libarkts/native/src/es2panda_lib.cc b/arkoala-arkts/libarkts/native/src/es2panda_lib.cc
new file mode 100644
index 0000000000000000000000000000000000000000..2febc81b10d13e9d77c8fe1e3508acfaa7d193eb
--- /dev/null
+++ b/arkoala-arkts/libarkts/native/src/es2panda_lib.cc
@@ -0,0 +1,1651 @@
+/*
+ * 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.
+ */
+
+ #include <iostream>
+ #include <string>
+ #include <vector>
+ 
+ #include "dynamic-loader.h"
+ #include "es2panda_lib.h"
+ #include "common-interop.h"
+ #include "stdexcept"
+ 
+ using std::string, std::cout, std::endl, std::vector;
+ 
+ static es2panda_Impl *impl = nullptr;
+ 
+ #ifdef KOALA_WINDOWS
+     #include <windows.h>
+     #define PLUGIN_DIR "windows_host_tools"
+     #define LIB_PREFIX ""
+     #define LIB_SUFFIX ".dll"
+ #endif
+ 
+ #ifdef KOALA_LINUX
+     #include <dlfcn.h>
+ 
+     #ifdef __x86_64__
+         #define PLUGIN_DIR "linux_host_tools"
+     #else
+         #define PLUGIN_DIR "linux_arm64_host_tools"
+     #endif
+ 
+     #define LIB_PREFIX "lib"
+     #define LIB_SUFFIX ".so"
+ #endif
+ 
+ const char* libpath = "../node_modules/@panda/sdk/" PLUGIN_DIR "/lib/" LIB_PREFIX "es2panda-public" LIB_SUFFIX;
+ 
+ es2panda_Impl *GetImpl() {
+     if (impl) {
+         return impl;
+     }
+     auto library =  loadLibrary(libpath);
+     if (!library) {
+         throw std::runtime_error("No library (es2panda_lib.cc)");
+     }
+     auto symbol = findSymbol(library, "es2panda_GetImpl");
+     if (!symbol) {
+         throw std::runtime_error("No entry point");
+     }
+     impl = reinterpret_cast<es2panda_Impl *(*)(int)>(symbol)(ES2PANDA_LIB_VERSION);
+     return impl;
+ }
+ 
+ es2panda_ContextState intToState(KInt state) {
+     return es2panda_ContextState(state);
+ }
+ 
+ string getString(KStringPtr ptr) {
+     return ptr.data();
+ }
+ 
+ char* getStringCopy(KStringPtr& ptr) {
+     return strdup(ptr.c_str());
+ }
+ 
+ inline KUInt unpackUInt(const KByte* bytes) {
+     return (bytes[0] | (bytes[1] << 8) | (bytes[2] << 16) | (bytes[3] << 24));
+ }
+ 
+ KInt impl_ContextState(KNativePointer contextPtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+ 
+     return static_cast<KInt>(GetImpl()->ContextState(context));
+ }
+ KOALA_INTEROP_1(ContextState, KInt, KNativePointer)
+ 
+ KNativePointer impl_ContextErrorMessage(KNativePointer contextPtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+ 
+     return new string(GetImpl()->ContextErrorMessage(context));
+ }
+ KOALA_INTEROP_1(ContextErrorMessage, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_CreateConfig(KInt argc, KStringArray argvPtr) {
+     const std::size_t HEADER_LEN = 4;
+ 
+     const char** argv = new const char*[argc];
+     std::size_t position = HEADER_LEN;
+     std::size_t str_len;
+     for (std::size_t i = 0; i < static_cast<std::size_t>(argc); ++i) {
+         str_len = unpackUInt(argvPtr + position);
+         position += HEADER_LEN;
+         argv[i] = strdup(std::string(reinterpret_cast<const char*>(argvPtr + position), str_len).c_str());
+         position += str_len;
+     }
+     return GetImpl()->CreateConfig(argc, argv);
+ }
+ KOALA_INTEROP_2(CreateConfig, KNativePointer, KInt, KStringArray)
+ 
+ KNativePointer impl_DestroyConfig(KNativePointer configPtr) {
+     auto config = reinterpret_cast<es2panda_Config*>(configPtr);
+     GetImpl()->DestroyConfig(config);
+     return nullptr;
+ }
+ KOALA_INTEROP_1(DestroyConfig, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_CreateContextFromString(KNativePointer configPtr, KStringPtr& sourcePtr, KStringPtr& filenamePtr) {
+     auto config = reinterpret_cast<es2panda_Config*>(configPtr);
+     return GetImpl()->CreateContextFromString(config, sourcePtr.data(), filenamePtr.data());
+ }
+ KOALA_INTEROP_3(CreateContextFromString, KNativePointer, KNativePointer, KStringPtr, KStringPtr)
+ 
+ KNativePointer impl_CreateContextFromFile(KNativePointer configPtr, KStringPtr& filenamePtr) {
+     auto config = reinterpret_cast<es2panda_Config*>(configPtr);
+     return GetImpl()->CreateContextFromFile(config, getStringCopy(filenamePtr));
+ }
+ KOALA_INTEROP_2(CreateContextFromFile, KNativePointer, KNativePointer, KStringPtr)
+ 
+ KNativePointer impl_DestroyContext(KNativePointer contextPtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     GetImpl()->DestroyContext(context);
+     return nullptr;
+ }
+ KOALA_INTEROP_1(DestroyContext, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_ProceedToState(KNativePointer contextPtr, KInt state) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     return GetImpl()->ProceedToState(context, intToState(state));
+ }
+ KOALA_INTEROP_2(ProceedToState, KNativePointer, KNativePointer, KInt)
+ 
+ KNativePointer impl_ContextProgram(KNativePointer contextPtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     return GetImpl()->ContextProgram(context);
+ }
+ KOALA_INTEROP_1(ContextProgram, KNativePointer, KNativePointer)
+ 
+ KBoolean impl_CheckerStartChecker(KNativePointer contextPtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     return GetImpl()->CheckerStartChecker(context);
+ }
+ KOALA_INTEROP_1(CheckerStartChecker, KBoolean, KNativePointer)
+ 
+ KNativePointer impl_VarBinderIdentifierAnalysis(KNativePointer contextPtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     GetImpl()->VarBinderIdentifierAnalysis(context);
+     return context;
+ }
+ KOALA_INTEROP_1(VarBinderIdentifierAnalysis, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_VarBinderInitTopScope(KNativePointer contextPtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     GetImpl()->VarBinderInitTopScope(context);
+     return context;
+ }
+ KOALA_INTEROP_1(VarBinderInitTopScope, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_ProgramAst(KNativePointer programPtr) {
+     auto program = reinterpret_cast<es2panda_Program*>(programPtr);
+     return GetImpl()->ProgramAst(program);
+ }
+ KOALA_INTEROP_1(ProgramAst, KNativePointer, KNativePointer)
+ 
+ KBoolean impl_IsIdentifier(KNativePointer nodePtr) {
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     return GetImpl()->IsIdentifier(node);
+ }
+ KOALA_INTEROP_1(IsIdentifier, KBoolean, KNativePointer)
+ 
+ KNativePointer impl_IdentifierName(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     return new string(GetImpl()->IdentifierName(context, node));
+ }
+ KOALA_INTEROP_2(IdentifierName, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_CreateIdentifier1(KNativePointer contextPtr, KStringPtr& namePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     return GetImpl()->CreateIdentifier1(context, getStringCopy(namePtr));
+ }
+ KOALA_INTEROP_2(CreateIdentifier1, KNativePointer, KNativePointer, KStringPtr)
+ 
+ KNativePointer impl_IdentifierSetName(KNativePointer contextPtr, KNativePointer nodePtr, KStringPtr& namePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     GetImpl()->IdentifierSetName(context, node, getStringCopy(namePtr));
+     return node;
+ }
+ KOALA_INTEROP_3(IdentifierSetName, KNativePointer, KNativePointer, KNativePointer, KStringPtr)
+ 
+ KNativePointer impl_CreateIdentifier2(KNativePointer contextPtr, KStringPtr& namePtr, KNativePointer typeAnnotationPtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto typeAnnotation = reinterpret_cast<es2panda_AstNode*>(typeAnnotationPtr);
+     return GetImpl()->CreateIdentifier2(context, getStringCopy(namePtr), typeAnnotation);
+ }
+ KOALA_INTEROP_3(CreateIdentifier2, KNativePointer, KNativePointer, KStringPtr, KNativePointer)
+ 
+ KNativePointer impl_CreateETSPrimitiveType(KNativePointer contextPtr, KInt type) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     return GetImpl()->CreateETSPrimitiveType(context, static_cast<Es2pandaPrimitiveType>(type));
+ }
+ KOALA_INTEROP_2(CreateETSPrimitiveType, KNativePointer, KNativePointer, KInt)
+ 
+ KInt impl_ETSPrimitiveTypeGetPrimitiveTypeConst(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->ETSPrimitiveTypeGetPrimitiveTypeConst(context, node);
+ }
+ KOALA_INTEROP_2(ETSPrimitiveTypeGetPrimitiveTypeConst, KInt, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_CreateETSFunctionTypeIr(KNativePointer contextPtr, KNativePointer signaturePtr, KInt funcFlagsT) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto signature = reinterpret_cast<es2panda_FunctionSignature*>(signaturePtr);
+     auto funcFlags = Es2pandaScriptFunctionFlags(funcFlagsT);
+ 
+     return GetImpl()->CreateETSFunctionTypeIr(context, signature, funcFlags);
+ }
+ KOALA_INTEROP_3(CreateETSFunctionTypeIr, KNativePointer, KNativePointer, KNativePointer, KInt)
+ 
+ KNativePointer impl_CreateNumberLiteral(KNativePointer contextPtr, KStringPtr& strPtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+ 
+     return GetImpl()->CreateNumberLiteral(context, getStringCopy(strPtr));
+ }
+ KOALA_INTEROP_2(CreateNumberLiteral, KNativePointer, KNativePointer, KStringPtr)
+ 
+ KNativePointer impl_CreateStringLiteral(KNativePointer contextPtr, KStringPtr& stringPtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     return GetImpl()->CreateStringLiteral1(context, getStringCopy(stringPtr));
+ }
+ KOALA_INTEROP_2(CreateStringLiteral, KNativePointer, KNativePointer, KStringPtr)
+ 
+ KNativePointer impl_StringLiteralStrConst(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     return new string(GetImpl()->StringLiteralStrConst(context, node));
+ }
+ KOALA_INTEROP_2(StringLiteralStrConst, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_NumberLiteralStrConst(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     return new string(GetImpl()->NumberLiteralStrConst(context, node));
+ }
+ KOALA_INTEROP_2(NumberLiteralStrConst, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_CreateMethodDefinition(
+     KNativePointer contextPtr,
+     KInt kindT,
+     KNativePointer keyPtr,
+     KNativePointer valuePtr,
+     KInt modifiersT,
+     KBoolean isComputedT
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto kind = static_cast<Es2pandaMethodDefinitionKind>(kindT);
+     auto key = reinterpret_cast<es2panda_AstNode*>(keyPtr);
+     auto value = reinterpret_cast<es2panda_AstNode*>(valuePtr);
+     auto modifiers = static_cast<Es2pandaModifierFlags>(modifiersT);
+     auto isComputed = static_cast<bool>(isComputedT);
+ 
+     return GetImpl()->CreateMethodDefinition(context, kind, key, value, modifiers, isComputed);
+ }
+ KOALA_INTEROP_6(CreateMethodDefinition, KNativePointer, KNativePointer, KInt, KNativePointer, KNativePointer, KInt, KBoolean)
+ 
+ KNativePointer impl_CreateClassProperty(
+     KNativePointer contextPtr,
+     KNativePointer keyPtr,
+     KNativePointer valuePtr,
+     KNativePointer typeAnnotationPtr,
+     KInt modifiersT,
+     KBoolean isComputedT
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto key = reinterpret_cast<es2panda_AstNode*>(keyPtr);
+     auto value = reinterpret_cast<es2panda_AstNode*>(valuePtr);
+     auto typeAnnotation = reinterpret_cast<es2panda_AstNode*>(typeAnnotationPtr);
+     auto modifiers = static_cast<Es2pandaModifierFlags>(modifiersT);
+     auto isComputed = static_cast<bool>(isComputedT);
+ 
+     return GetImpl()->CreateClassProperty(context, key, value, typeAnnotation, modifiers, isComputed);
+ }
+ KOALA_INTEROP_6(CreateClassProperty, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt, KBoolean)
+ 
+ KNativePointer impl_AstNodeDumpJsonConst(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     return new string(GetImpl()->AstNodeDumpJSONConst(context, node));
+ }
+ KOALA_INTEROP_2(AstNodeDumpJsonConst, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_AstNodeDumpEtsSrcConst(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     return new string(GetImpl()->AstNodeDumpEtsSrcConst(context, node));
+ }
+ KOALA_INTEROP_2(AstNodeDumpEtsSrcConst, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_ETSParserCreateExpression(KNativePointer contextPtr, KStringPtr& sourceCodePtr, KInt flagsT) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto flags = static_cast<Es2pandaExpressionParseFlags>(flagsT);
+ 
+     return GetImpl()->ETSParserCreateExpression(context, getStringCopy(sourceCodePtr), flags);
+ }
+ KOALA_INTEROP_3(ETSParserCreateExpression, KNativePointer, KNativePointer, KStringPtr, KInt)
+ 
+ KBoolean impl_IsProgram(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     return GetImpl()->AstNodeIsProgramConst(context, node);
+ }
+ KOALA_INTEROP_2(IsProgram, KBoolean, KNativePointer, KNativePointer)
+ 
+ KBoolean impl_IsBlockStatement(KNativePointer nodePtr) {
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     return GetImpl()->IsBlockStatement(node);
+ }
+ KOALA_INTEROP_1(IsBlockStatement, KBoolean, KNativePointer)
+ 
+ KNativePointer impl_BlockStatementStatements(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     size_t n;
+     auto statements = GetImpl()->BlockStatementStatements(context, node, &n);
+     return new vector<void*>(statements, statements + n);
+ }
+ KOALA_INTEROP_2(BlockStatementStatements, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_VariableDeclarationDeclaratorsConst(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     size_t n;
+     auto declarators = GetImpl()->VariableDeclarationDeclaratorsConst(context, node, &n);
+     return new vector<void*>(declarators, declarators + n);
+ }
+ KOALA_INTEROP_2(VariableDeclarationDeclaratorsConst, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KInt impl_VariableDeclarationKindConst(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->VariableDeclarationKindConst(context, node);
+ }
+ KOALA_INTEROP_2(VariableDeclarationKindConst, KInt, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_ClassDeclarationDefinition(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     return GetImpl()->ClassDeclarationDefinition(context, node);
+ }
+ KOALA_INTEROP_2(ClassDeclarationDefinition, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_ClassDefinitionBody(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     size_t n;
+     auto body = GetImpl()->ClassDefinitionBody(context, node, &n);
+     return new std::vector<void*>(body, body + n);
+ }
+ KOALA_INTEROP_2(ClassDefinitionBody, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_ClassDefinitionTypeParamsConst(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return const_cast<es2panda_AstNode*>(GetImpl()->ClassDefinitionTypeParamsConst(context, node));
+ }
+ KOALA_INTEROP_2(ClassDefinitionTypeParamsConst, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_FunctionDeclarationFunction(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     return GetImpl()->FunctionDeclarationFunction(context, node);
+ }
+ KOALA_INTEROP_2(FunctionDeclarationFunction, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KBoolean impl_FunctionDeclarationIsAnonymousConst(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->FunctionDeclarationIsAnonymousConst(context, node);
+ }
+ KOALA_INTEROP_2(FunctionDeclarationIsAnonymousConst, KBoolean, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_ScriptFunctionAddFlag(KNativePointer contextPtr, KNativePointer nodePtr, KInt flagsT) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     auto flags = static_cast<Es2pandaScriptFunctionFlags>(flagsT);
+ 
+     GetImpl()->ScriptFunctionAddFlag(context, node, flags);
+     return node;
+ }
+ KOALA_INTEROP_3(ScriptFunctionAddFlag, KNativePointer, KNativePointer, KNativePointer, KInt)
+ 
+ KNativePointer impl_ScriptFunctionParams(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     std::size_t params_len = 0;
+     auto params = GetImpl()->ScriptFunctionParams(context, node, &params_len);
+     return new std::vector<void*>(params, params + params_len);
+ }
+ KOALA_INTEROP_2(ScriptFunctionParams, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_ScriptFunctionTypeParams(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->ScriptFunctionTypeParams(context, node);
+ }
+ KOALA_INTEROP_2(ScriptFunctionTypeParams, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_ScriptFunctionReturnTypeAnnotation(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->ScriptFunctionReturnTypeAnnotation(context, node);
+ }
+ KOALA_INTEROP_2(ScriptFunctionReturnTypeAnnotation, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_ScriptFunctionId(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     return GetImpl()->ScriptFunctionId(context, node);
+ }
+ KOALA_INTEROP_2(ScriptFunctionId, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KBoolean impl_ScriptFunctionDeclareConst(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     return GetImpl()->ScriptFunctionDeclareConst(context, node);
+ }
+ KOALA_INTEROP_2(ScriptFunctionDeclareConst, KBoolean, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_CreateFunctionDeclaration(
+     KNativePointer contextPtr,
+     KNativePointer funcPtr,
+     KNativePointerArray annotationsPtr,
+     KInt annotationsLen,
+     KBoolean isAnonK
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto func = reinterpret_cast<es2panda_AstNode*>(funcPtr);
+     auto annotations = reinterpret_cast<es2panda_AstNode**>(annotationsPtr);
+     auto isAnon = static_cast<bool>(isAnonK);
+ 
+     return GetImpl()->CreateFunctionDeclaration(context, func, annotations, annotationsLen, isAnon);
+ }
+ KOALA_INTEROP_5(CreateFunctionDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KInt, KBoolean)
+ 
+ KNativePointer impl_UpdateFunctionDeclaration(
+     KNativePointer contextPtr,
+     KNativePointer nodePtr,
+     KNativePointer funcPtr,
+     KNativePointerArray annotationsPtr,
+     KInt annotationsLen,
+     KBoolean isAnonK
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     auto func = reinterpret_cast<es2panda_AstNode*>(funcPtr);
+     auto annotations = reinterpret_cast<es2panda_AstNode**>(annotationsPtr);
+     auto isAnon = static_cast<bool>(isAnonK);
+ 
+     return GetImpl()->UpdateFunctionDeclaration(context, node, func, annotations, annotationsLen, isAnon);
+ }
+ KOALA_INTEROP_6(UpdateFunctionDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KInt, KBoolean)
+ 
+ // TODO: add param initializer
+ KNativePointer impl_CreateETSParameterExpression(KNativePointer contextPtr, KNativePointer identifierPtr, KNativePointer initializerPtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto identifier = reinterpret_cast<es2panda_AstNode*>(identifierPtr);
+     auto initializer = reinterpret_cast<es2panda_AstNode*>(initializerPtr);
+ 
+     return GetImpl()->CreateETSParameterExpression(context, identifier, initializer);
+ }
+ KOALA_INTEROP_3(CreateETSParameterExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_CreateTSTypeParameterDeclaration(
+     KNativePointer contextPtr,
+     KNativePointerArray paramsPtr,
+     KInt paramsLen,
+     KInt requiredParams
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto params = reinterpret_cast<es2panda_AstNode**>(paramsPtr);
+ 
+     return GetImpl()->CreateTSTypeParameterDeclaration(context, params, paramsLen, requiredParams);
+ }
+ KOALA_INTEROP_4(CreateTSTypeParameterDeclaration, KNativePointer, KNativePointer, KNativePointerArray, KInt, KInt)
+ 
+ KNativePointer impl_TSTypeParameterDeclarationParamsConst(KNativePointer contextPtr, KNativePointer nodePtr, KNativePointer returnLen) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     std::size_t params_len = 0;
+     auto params = GetImpl()->TSTypeParameterDeclarationParamsConst(context, node, &params_len);
+     return new std::vector<void*>(params, params + params_len);
+ }
+ KOALA_INTEROP_3(TSTypeParameterDeclarationParamsConst, KNativePointer, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_CreateVariableDeclaration(
+     KNativePointer contextPtr,
+     KInt kindT,
+     KNativePointerArray declaratorsPtr,
+     KInt declaratorsLen,
+     KBoolean declareT
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto kind = static_cast<Es2pandaVariableDeclarationKind>(kindT);
+     auto declarators = reinterpret_cast<es2panda_AstNode**>(declaratorsPtr);
+     auto declare = static_cast<bool>(declareT);
+ 
+     return GetImpl()->CreateVariableDeclaration(context, kind, declarators, declaratorsLen, declare);
+ }
+ KOALA_INTEROP_5(CreateVariableDeclaration, KNativePointer, KNativePointer, KInt, KNativePointerArray, KInt, KBoolean)
+ 
+ KNativePointer impl_UpdateVariableDeclaration(
+     KNativePointer contextPtr,
+     KNativePointer originalPtr,
+     KInt kindT,
+     KNativePointerArray declaratorsPtr,
+     KInt declaratorsLen,
+     KBoolean declareT
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto original = reinterpret_cast<es2panda_AstNode*>(originalPtr);
+     auto kind = static_cast<Es2pandaVariableDeclarationKind>(kindT);
+     auto declarators = reinterpret_cast<es2panda_AstNode**>(declaratorsPtr);
+     auto declare = static_cast<bool>(declareT);
+ 
+     return GetImpl()->UpdateVariableDeclaration(context, original, kind, declarators, declaratorsLen, declare);
+ }
+ KOALA_INTEROP_6(UpdateVariableDeclaration, KNativePointer, KNativePointer, KNativePointer, KInt, KNativePointerArray, KInt, KBoolean)
+ 
+ KNativePointer impl_CreateVariableDeclarator(
+     KNativePointer contextPtr,
+     KInt flagT,
+     KNativePointer identPtr
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto flag = static_cast<Es2pandaVariableDeclaratorFlag>(flagT);
+     auto ident = reinterpret_cast<es2panda_AstNode*>(identPtr);
+ 
+     return GetImpl()->CreateVariableDeclarator(context, flag, ident);
+ }
+ KOALA_INTEROP_3(CreateVariableDeclarator, KNativePointer, KNativePointer, KInt, KNativePointer)
+ 
+ KNativePointer impl_VariableDeclaratorSetInit(KNativePointer contextPtr, KNativePointer nodePtr, KNativePointer initPtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     auto init = reinterpret_cast<es2panda_AstNode*>(initPtr);
+ 
+     GetImpl()->VariableDeclaratorSetInit(context, node, init);
+     return node;
+ }
+ KOALA_INTEROP_3(VariableDeclaratorSetInit, KNativePointer, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_VariableDeclaratorId(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->VariableDeclaratorId(context, node);
+ }
+ KOALA_INTEROP_2(VariableDeclaratorId, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_CreateTSTypeParameter(
+     KNativePointer contextPtr,
+     KNativePointer namePtr,
+     KNativePointer constraintPtr,
+     KNativePointer defaultTypePtr
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto name = reinterpret_cast<es2panda_AstNode*>(namePtr);
+     auto constraint = reinterpret_cast<es2panda_AstNode*>(constraintPtr);
+     auto defaultType = reinterpret_cast<es2panda_AstNode*>(defaultTypePtr);
+ 
+     return GetImpl()->CreateTSTypeParameter(context, name, constraint, defaultType);
+ }
+ KOALA_INTEROP_4(CreateTSTypeParameter, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_TSTypeParameterName(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->TSTypeParameterName(context, node);
+ }
+ KOALA_INTEROP_2(TSTypeParameterName, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_ETSParameterExpressionIdent(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->ETSParameterExpressionIdent(context, node);
+ }
+ KOALA_INTEROP_2(ETSParameterExpressionIdent, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_CreateETSTypeReference(KNativePointer contextPtr, KNativePointer partPtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto part = reinterpret_cast<es2panda_AstNode*>(partPtr);
+ 
+     return GetImpl()->CreateETSTypeReference(context, part);
+ }
+ KOALA_INTEROP_2(CreateETSTypeReference, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_CreateETSTypeReferencePart1(KNativePointer contextPtr, KNativePointer namePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto name = reinterpret_cast<es2panda_AstNode*>(namePtr);
+ 
+     return GetImpl()->CreateETSTypeReferencePart1(context, name);
+ }
+ KOALA_INTEROP_2(CreateETSTypeReferencePart1, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_CreateETSTypeReferencePart(KNativePointer contextPtr, KNativePointer namePtr, KNativePointer typeParamsPtr, KNativePointer prevPtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto name = reinterpret_cast<es2panda_AstNode*>(namePtr);
+     auto typeParams = reinterpret_cast<es2panda_AstNode*>(typeParamsPtr);
+     auto prev = reinterpret_cast<es2panda_AstNode*>(prevPtr);
+ 
+     return GetImpl()->CreateETSTypeReferencePart(context, name, typeParams, prev);
+ }
+ KOALA_INTEROP_4(CreateETSTypeReferencePart, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_UpdateBlockStatement(KNativePointer contextPtr, KNativePointer originalPtr, KNativePointerArray statementListPtr, KInt statementListLen) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto statementList = reinterpret_cast<es2panda_AstNode**>(statementListPtr);
+     auto original = reinterpret_cast<es2panda_AstNode*>(originalPtr);
+ 
+     // tmp solution while waiting fix for UpdateBlockStatement
+     GetImpl()->BlockStatementSetStatements(context, original, statementList, static_cast<std::size_t>(statementListLen));
+     return original;
+ }
+ KOALA_INTEROP_4(UpdateBlockStatement, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KInt)
+ 
+ KNativePointer impl_CreateReturnStatement1(KNativePointer contextPtr, KNativePointer argumentPtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto argument = reinterpret_cast<es2panda_AstNode*>(argumentPtr);
+ 
+     return GetImpl()->CreateReturnStatement1(context, argument);
+ }
+ KOALA_INTEROP_2(CreateReturnStatement1, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_ReturnStatementArgument(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->ReturnStatementArgument(context, node);
+ }
+ KOALA_INTEROP_2(ReturnStatementArgument, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_CreateIfStatement(KNativePointer contextPtr, KNativePointer testPtr, KNativePointer consequentPtr, KNativePointer alternatePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto test = reinterpret_cast<es2panda_AstNode*>(testPtr);
+     auto consequent = reinterpret_cast<es2panda_AstNode*>(consequentPtr);
+     auto alternate = reinterpret_cast<es2panda_AstNode*>(alternatePtr);
+ 
+     return GetImpl()->CreateIfStatement(context, test, consequent, alternate);
+ }
+ KOALA_INTEROP_4(CreateIfStatement, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_CreateMemberExpression(
+     KNativePointer contextPtr,
+     KNativePointer objectPtr,
+     KNativePointer propertyPtr,
+     KInt kindT,
+     KBoolean computedT,
+     KBoolean optionalT
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto object = reinterpret_cast<es2panda_AstNode*>(objectPtr);
+     auto property = reinterpret_cast<es2panda_AstNode*>(propertyPtr);
+     auto computed = static_cast<bool>(computedT);
+     auto optional = static_cast<bool>(optionalT);
+     auto kind = static_cast<Es2pandaMemberExpressionKind>(kindT);
+ 
+     return GetImpl()->CreateMemberExpression(context, object, property, kind, computed, optional);
+ }
+ KOALA_INTEROP_6(CreateMemberExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt, KBoolean, KBoolean)
+ 
+ KNativePointer impl_UpdateMemberExpression(
+     KNativePointer contextPtr,
+     KNativePointer nodePtr,
+     KNativePointer objectPtr,
+     KNativePointer propertyPtr,
+     KInt kindT,
+     KBoolean computedT,
+     KBoolean optionalT
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     auto object = reinterpret_cast<es2panda_AstNode*>(objectPtr);
+     auto property = reinterpret_cast<es2panda_AstNode*>(propertyPtr);
+     auto computed = static_cast<bool>(computedT);
+     auto optional = static_cast<bool>(optionalT);
+     auto kind = static_cast<Es2pandaMemberExpressionKind>(kindT);
+ 
+     return GetImpl()->UpdateMemberExpression(context, node, object, property, kind, computed, optional);
+ }
+ KOALA_INTEROP_7(UpdateMemberExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt, KBoolean, KBoolean)
+ 
+ KNativePointer impl_UpdateMethodDefinition(
+     KNativePointer contextPtr,
+     KNativePointer nodePtr,
+     KInt kindT,
+     KNativePointer keyPtr,
+     KNativePointer valuePtr,
+     KInt modifiersT,
+     KBoolean isComputedT
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     auto kind = static_cast<Es2pandaMethodDefinitionKind>(kindT);
+     auto key = reinterpret_cast<es2panda_AstNode*>(keyPtr);
+     auto value = reinterpret_cast<es2panda_AstNode*>(valuePtr);
+     auto modifiers = static_cast<Es2pandaModifierFlags>(modifiersT);
+     auto isComputed = static_cast<bool>(isComputedT);
+ 
+     return GetImpl()->UpdateMethodDefinition(context, node, kind, key, value, modifiers, isComputed);
+ }
+ KOALA_INTEROP_7(UpdateMethodDefinition, KNativePointer, KNativePointer, KNativePointer, KInt, KNativePointer, KNativePointer, KInt, KBoolean)
+ 
+ KNativePointer impl_MemberExpressionObject(
+     KNativePointer contextPtr,
+     KNativePointer nodePtr
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->MemberExpressionObject(context, node);
+ }
+ KOALA_INTEROP_2(MemberExpressionObject, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_MemberExpressionProperty(
+     KNativePointer contextPtr,
+     KNativePointer nodePtr
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->MemberExpressionProperty(context, node);
+ }
+ KOALA_INTEROP_2(MemberExpressionProperty, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KInt impl_MemberExpressionKindConst(
+     KNativePointer contextPtr,
+     KNativePointer nodePtr
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->MemberExpressionKindConst(context, node);
+ }
+ KOALA_INTEROP_2(MemberExpressionKindConst, KInt, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_CreateCallExpression(
+     KNativePointer contextPtr,
+     KNativePointer calleePtr,
+     KNativePointerArray argumentsPtr,
+     KInt argumentsLen,
+     KNativePointer typeParamsPtr,
+     KBoolean optionalT,
+     KBoolean trailingCommaT
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto callee = reinterpret_cast<es2panda_AstNode*>(calleePtr);
+     auto arguments = reinterpret_cast<es2panda_AstNode**>(argumentsPtr);
+     auto typeParams = reinterpret_cast<es2panda_AstNode*>(typeParamsPtr);
+     auto optional = static_cast<bool>(optionalT);
+     auto trailingComma = static_cast<bool>(trailingCommaT);
+ 
+     return GetImpl()->CreateCallExpression(context, callee, arguments, argumentsLen, typeParams, optional, trailingComma);
+ }
+ KOALA_INTEROP_7(CreateCallExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KInt, KNativePointer, KBoolean, KBoolean)
+ 
+ KNativePointer impl_UpdateCallExpression(
+     KNativePointer contextPtr,
+     KNativePointer nodePtr,
+     KNativePointer calleePtr,
+     KNativePointerArray argumentsPtr,
+     KInt argumentsLen,
+     KNativePointer typeParamsPtr,
+     KBoolean optionalT,
+     KBoolean trailingCommaT
+ ) {
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto callee = reinterpret_cast<es2panda_AstNode*>(calleePtr);
+     auto arguments = reinterpret_cast<es2panda_AstNode**>(argumentsPtr);
+     auto typeParams = reinterpret_cast<es2panda_AstNode*>(typeParamsPtr);
+     auto optional = static_cast<bool>(optionalT);
+     auto trailingComma = static_cast<bool>(trailingCommaT);
+ 
+     // auto nn = GetImpl()->UpdateCallExpression(context, node, callee, arguments, argumentsLen, typeParams, optional, trailingComma);
+     auto nn = GetImpl()->CreateCallExpression(context, callee, arguments, argumentsLen, typeParams, optional, trailingComma);
+     GetImpl()->AstNodeSetOriginalNode(context, nn, node);
+     return nn;
+ }
+ KOALA_INTEROP_8(UpdateCallExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KInt, KNativePointer, KBoolean, KBoolean)
+ 
+ KNativePointer impl_CreateExpressionStatement(KNativePointer contextPtr, KNativePointer exprPtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto expr = reinterpret_cast<es2panda_AstNode*>(exprPtr);
+ 
+     return GetImpl()->CreateExpressionStatement(context, expr);
+ }
+ KOALA_INTEROP_2(CreateExpressionStatement, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_UpdateExpressionStatement(KNativePointer contextPtr, KNativePointer nodePtr, KNativePointer exprPtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     auto expr = reinterpret_cast<es2panda_AstNode*>(exprPtr);
+ 
+     return GetImpl()->UpdateExpressionStatement(context, node, expr);
+ }
+ KOALA_INTEROP_3(UpdateExpressionStatement, KNativePointer, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_ScriptFunctionBody(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->ScriptFunctionBody(context, node);
+ }
+ KOALA_INTEROP_2(ScriptFunctionBody, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_CreateBinaryExpression(KNativePointer contextPtr, KNativePointer leftPtr, KNativePointer rightPtr, KInt tokenKind) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto left = reinterpret_cast<es2panda_AstNode*>(leftPtr);
+     auto right = reinterpret_cast<es2panda_AstNode*>(rightPtr);
+ 
+     return GetImpl()->CreateBinaryExpression(context, left, right, Es2pandaTokenType(tokenKind));
+ }
+ KOALA_INTEROP_4(CreateBinaryExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt)
+ 
+ KNativePointer impl_CreateAssignmentExpression(KNativePointer contextPtr, KNativePointer leftPtr, KNativePointer rightPtr, KInt assignmentOperator) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto left = reinterpret_cast<es2panda_AstNode*>(leftPtr);
+     auto right = reinterpret_cast<es2panda_AstNode*>(rightPtr);
+ 
+     return GetImpl()->CreateAssignmentExpression(context, left, right, Es2pandaTokenType(assignmentOperator));
+ }
+ KOALA_INTEROP_4(CreateAssignmentExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt)
+ 
+ KNativePointer impl_CreateFunctionSignature(
+     KNativePointer contextPtr,
+     KNativePointer typeParamsPtr,
+     KNativePointerArray paramsPtr,
+     KInt paramsLen,
+     KNativePointer returnTypeAnnotationPtr
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto typeParams = reinterpret_cast<es2panda_AstNode*>(typeParamsPtr);
+     auto params = reinterpret_cast<es2panda_AstNode**>(paramsPtr);
+     auto returnTypeAnnotation = reinterpret_cast<es2panda_AstNode*>(returnTypeAnnotationPtr);
+ 
+     return GetImpl()->CreateFunctionSignature(context, typeParams, params, paramsLen, returnTypeAnnotation);
+ }
+ KOALA_INTEROP_5(CreateFunctionSignature, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KInt, KNativePointer)
+ 
+ KNativePointer impl_CreateTSUnionType(
+     KNativePointer contextPtr,
+     KNativePointerArray typesPtr,
+     KInt typesLen
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto types = reinterpret_cast<es2panda_AstNode**>(typesPtr);
+ 
+     return GetImpl()->CreateTSUnionType(context, types, typesLen);
+ }
+ KOALA_INTEROP_3(CreateTSUnionType, KNativePointer, KNativePointer, KNativePointerArray, KInt)
+ 
+ KNativePointer impl_TSUnionTypeTypesConst(KNativePointer contextPtr, KNativePointer nodePtr, KNativePointer returnLen) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     std::size_t params_len = 0;
+     auto params = GetImpl()->TSUnionTypeTypesConst(context, node, &params_len);
+ 
+     return new std::vector<void*>(params, params + params_len);
+ }
+ KOALA_INTEROP_3(TSUnionTypeTypesConst, KNativePointer, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_CreateETSUnionTypeIr(
+     KNativePointer contextPtr,
+     KNativePointerArray typesPtr,
+     KInt typesLen
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto types = reinterpret_cast<es2panda_AstNode**>(typesPtr);
+ 
+     return GetImpl()->CreateETSUnionTypeIr(context, types, typesLen);
+ }
+ KOALA_INTEROP_3(CreateETSUnionTypeIr, KNativePointer, KNativePointer, KNativePointerArray, KInt)
+ 
+ KNativePointer impl_ETSUnionTypeIrTypesConst(KNativePointer contextPtr, KNativePointer nodePtr, KNativePointer returnLen) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     std::size_t params_len = 0;
+     auto params = GetImpl()->ETSUnionTypeIrTypesConst(context, node, &params_len);
+ 
+     return new std::vector<void*>(params, params + params_len);
+ }
+ KOALA_INTEROP_3(ETSUnionTypeIrTypesConst, KNativePointer, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_CreateScriptFunction(
+     KNativePointer contextPtr,
+     KNativePointer databodyPtr,
+     KNativePointer datasignaturePtr,
+     KInt datafuncFlags,
+     KInt dataFlags,
+     KBoolean datadeclare
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto databody = reinterpret_cast<es2panda_AstNode*>(databodyPtr);
+     auto datasignature = reinterpret_cast<es2panda_FunctionSignature*>(datasignaturePtr);
+ 
+     return GetImpl()->CreateScriptFunction(context, databody, datasignature, datafuncFlags, dataFlags, datadeclare);
+ }
+ KOALA_INTEROP_6(CreateScriptFunction, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt, KInt, KBoolean)
+ 
+ KNativePointer impl_UpdateScriptFunction(
+     KNativePointer contextPtr,
+     KNativePointer nodePtr,
+     KNativePointer databodyPtr,
+     KNativePointer datasignaturePtr,
+     KInt datafuncFlags,
+     KInt dataFlags,
+     KBoolean datadeclare
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     auto databody = reinterpret_cast<es2panda_AstNode*>(databodyPtr);
+     auto datasignature = reinterpret_cast<es2panda_FunctionSignature*>(datasignaturePtr);
+ 
+     return GetImpl()->UpdateScriptFunction(context, node, databody, datasignature, datafuncFlags, dataFlags, datadeclare);
+ }
+ KOALA_INTEROP_7(UpdateScriptFunction, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt, KInt, KBoolean)
+ 
+ KNativePointer impl_CreateBlockStatement(
+     KNativePointer contextPtr,
+     KNativePointerArray statementListPtr,
+     KInt statementListLen
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto statementList = reinterpret_cast<es2panda_AstNode**>(statementListPtr);
+ 
+     return GetImpl()->CreateBlockStatement(context, statementList, statementListLen);
+ }
+ KOALA_INTEROP_3(CreateBlockStatement, KNativePointer, KNativePointer, KNativePointerArray, KInt)
+ 
+ KNativePointer impl_CreateAstDumper(
+     KNativePointer contextPtr,
+     KNativePointer nodePtr,
+     KStringPtr& sourcePtr
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->CreateAstDumper(context, node, getStringCopy(sourcePtr));
+ }
+ KOALA_INTEROP_3(CreateAstDumper, KNativePointer, KNativePointer, KNativePointer, KStringPtr)
+ 
+ KNativePointer impl_AstDumperModifierToString(
+     KNativePointer contextPtr,
+     KNativePointer dumperPtr,
+     KInt flagsT
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto dumper = reinterpret_cast<es2panda_AstDumper*>(dumperPtr);
+     auto flags = static_cast<Es2pandaModifierFlags>(flagsT);
+ 
+     return new std::string(GetImpl()->AstDumperModifierToString(context, dumper, flags));
+ }
+ KOALA_INTEROP_3(AstDumperModifierToString, KNativePointer, KNativePointer, KNativePointer, KInt)
+ 
+ KNativePointer impl_MethodDefinitionFunction(
+     KNativePointer contextPtr,
+     KNativePointer nodePtr
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->MethodDefinitionFunction(context, node);
+ }
+ KOALA_INTEROP_2(MethodDefinitionFunction, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KInt impl_MethodDefinitionKindConst(
+     KNativePointer contextPtr,
+     KNativePointer nodePtr
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->MethodDefinitionKindConst(context, node);
+ }
+ KOALA_INTEROP_2(MethodDefinitionKindConst, KInt, KNativePointer, KNativePointer)
+ 
+ 
+ KNativePointer impl_AstNodeSetParent(
+     KNativePointer contextPtr,
+     KNativePointer astPtr,
+     KNativePointer parentPtr
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto ast = reinterpret_cast<es2panda_AstNode*>(astPtr);
+     auto parent = reinterpret_cast<es2panda_AstNode*>(parentPtr);
+ 
+     GetImpl()->AstNodeSetParent(context, ast, parent);
+     return ast;
+ }
+ KOALA_INTEROP_3(AstNodeSetParent, KNativePointer, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_AstNodeSetOriginalNode(
+     KNativePointer contextPtr,
+     KNativePointer astPtr,
+     KNativePointer originalNodePtr
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto ast = reinterpret_cast<es2panda_AstNode*>(astPtr);
+     auto originalNode = reinterpret_cast<es2panda_AstNode*>(originalNodePtr);
+ 
+     GetImpl()->AstNodeSetOriginalNode(context, ast, originalNode);
+     return ast;
+ }
+ KOALA_INTEROP_3(AstNodeSetOriginalNode, KNativePointer, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_AstNodeOriginalNodeConst(
+     KNativePointer contextPtr,
+     KNativePointer astPtr
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto ast = reinterpret_cast<es2panda_AstNode*>(astPtr);
+ 
+     return GetImpl()->AstNodeOriginalNodeConst(context, ast);
+ }
+ KOALA_INTEROP_2(AstNodeOriginalNodeConst, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_AstNodeClone(
+     KNativePointer contextPtr,
+     KNativePointer astPtr,
+     KNativePointer parentPtr
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto ast = reinterpret_cast<es2panda_AstNode*>(astPtr);
+     auto parent = reinterpret_cast<es2panda_AstNode*>(parentPtr);
+ 
+     return GetImpl()->AstNodeClone(context, ast, parent);
+ }
+ KOALA_INTEROP_3(AstNodeClone, KNativePointer, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_ScriptFunctionSetIdent(
+     KNativePointer contextPtr,
+     KNativePointer astPtr,
+     KNativePointer idPtr
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto ast = reinterpret_cast<es2panda_AstNode*>(astPtr);
+     auto id = reinterpret_cast<es2panda_AstNode*>(idPtr);
+ 
+     GetImpl()->ScriptFunctionSetIdent(context, ast, id);
+     return ast;
+ }
+ KOALA_INTEROP_3(ScriptFunctionSetIdent, KNativePointer, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_ScriptFunctionSetSignature(
+     KNativePointer contextPtr,
+     KNativePointer astPtr,
+     KNativePointer signaturePtr
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto ast = reinterpret_cast<es2panda_AstNode*>(astPtr);
+     auto signature = reinterpret_cast<es2panda_Signature*>(signaturePtr);
+ 
+     GetImpl()->ScriptFunctionSetSignature(context, ast, signature);
+     return ast;
+ }
+ KOALA_INTEROP_3(ScriptFunctionSetSignature, KNativePointer, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_ScriptFunctionSetBody(
+     KNativePointer contextPtr,
+     KNativePointer astPtr,
+     KNativePointer bodyPtr
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto ast = reinterpret_cast<es2panda_AstNode*>(astPtr);
+     auto body = reinterpret_cast<es2panda_AstNode*>(bodyPtr);
+ 
+     GetImpl()->ScriptFunctionSetBody(context, ast, body);
+     return ast;
+ }
+ KOALA_INTEROP_3(ScriptFunctionSetBody, KNativePointer, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_ScriptFunctionSetScope(
+     KNativePointer contextPtr,
+     KNativePointer astPtr,
+     KNativePointer scopePtr
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto ast = reinterpret_cast<es2panda_AstNode*>(astPtr);
+     auto scope = reinterpret_cast<es2panda_Scope*>(scopePtr);
+ 
+     GetImpl()->ScriptFunctionSetScope(context, ast, scope);
+     return ast;
+ }
+ KOALA_INTEROP_3(ScriptFunctionSetScope, KNativePointer, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_ScriptFunctionSignature(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->ScriptFunctionSignature(context, node);
+ }
+ KOALA_INTEROP_2(ScriptFunctionSignature, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_ScriptFunctionIrSignature(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->ScriptFunctionIrSignature(context, node);
+ }
+ KOALA_INTEROP_2(ScriptFunctionIrSignature, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KInt impl_ScriptFunctionFlagsConst(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->ScriptFunctionFlagsConst(context, node);
+ }
+ KOALA_INTEROP_2(ScriptFunctionFlagsConst, KInt, KNativePointer, KNativePointer)
+ 
+ KInt impl_AstNodeModifiers(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->AstNodeModifiers(context, node);
+ }
+ KOALA_INTEROP_2(AstNodeModifiers, KInt, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_AstNodeAddModifier(KNativePointer contextPtr, KNativePointer nodePtr, KInt flagsT) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     auto flags = static_cast<Es2pandaModifierFlags>(flagsT);
+ 
+     GetImpl()->AstNodeAddModifier(context, node, flags);
+     return node;
+ }
+ KOALA_INTEROP_3(AstNodeAddModifier, KNativePointer, KNativePointer, KNativePointer, KInt)
+ 
+ KNativePointer impl_AstNodeClearModifier(KNativePointer contextPtr, KNativePointer nodePtr, KInt flagsT) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     auto flags = static_cast<Es2pandaModifierFlags>(flagsT);
+ 
+     GetImpl()->AstNodeClearModifier(context, node, flags);
+     return node;
+ }
+ KOALA_INTEROP_3(AstNodeClearModifier, KNativePointer, KNativePointer, KNativePointer, KInt)
+ 
+ KNativePointer impl_FunctionSignatureParamsConst(KNativePointer contextPtr, KNativePointer nodePtr, KNativePointer returnTypeLen) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_FunctionSignature*>(nodePtr);
+     std::size_t params_len = 0;
+     auto params = GetImpl()->FunctionSignatureParamsConst(context, node, &params_len);
+     return new std::vector<void*>(params, params + params_len);
+ }
+ KOALA_INTEROP_3(FunctionSignatureParamsConst, KNativePointer, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_FunctionSignatureTypeParams(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_FunctionSignature*>(nodePtr);
+ 
+     return GetImpl()->FunctionSignatureTypeParams(context, node);
+ }
+ KOALA_INTEROP_2(FunctionSignatureTypeParams, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_FunctionSignatureReturnType(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_FunctionSignature*>(nodePtr);
+ 
+     return GetImpl()->FunctionSignatureReturnType(context, node);
+ }
+ KOALA_INTEROP_2(FunctionSignatureReturnType, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_UpdateIdentifier1(KNativePointer contextPtr, KNativePointer nodePtr, KStringPtr& namePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->UpdateIdentifier1(context, node, getStringCopy(namePtr));
+ }
+ KOALA_INTEROP_3(UpdateIdentifier1, KNativePointer, KNativePointer, KNativePointer, KStringPtr)
+ 
+ KNativePointer impl_UpdateIdentifier2(KNativePointer contextPtr, KNativePointer nodePtr, KStringPtr& namePtr, KNativePointer typeAnnotationPtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     auto typeAnnotation = reinterpret_cast<es2panda_AstNode*>(typeAnnotationPtr);
+ 
+     return GetImpl()->UpdateIdentifier2(context, node, getStringCopy(namePtr), typeAnnotation);
+ }
+ KOALA_INTEROP_4(UpdateIdentifier2, KNativePointer, KNativePointer, KNativePointer, KStringPtr, KNativePointer)
+ 
+ KBoolean impl_IdentifierIsPrivateIdentConst(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->IdentifierIsPrivateIdentConst(context, node);
+ }
+ KOALA_INTEROP_2(IdentifierIsPrivateIdentConst, KBoolean, KNativePointer, KNativePointer)
+ 
+ KInt impl_IdentifierIdentifierFlags(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return
+         (GetImpl()->IdentifierIsOptionalConst(context, node) ? (1 << 0) : 0) |
+         (GetImpl()->IdentifierIsReferenceConst(context, node, Es2pandaScriptExtension::SCRIPT_EXTENSION_TS) ? (1 << 1) : 0) |
+         (GetImpl()->IdentifierIsTdzConst(context, node) ? (1 << 2) : 0);
+ }
+ KOALA_INTEROP_2(IdentifierIdentifierFlags, KInt, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_CreateFunctionExpression(KNativePointer contextPtr, KNativePointer funcPtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto func = reinterpret_cast<es2panda_AstNode*>(funcPtr);
+ 
+     return GetImpl()->CreateFunctionExpression(context, func);
+ }
+ KOALA_INTEROP_2(CreateFunctionExpression, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_UpdateFunctionExpression(KNativePointer contextPtr, KNativePointer nodePtr, KNativePointer funcPtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     auto func = reinterpret_cast<es2panda_AstNode*>(funcPtr);
+ 
+     return GetImpl()->UpdateFunctionExpression(context, node, func);
+ }
+ KOALA_INTEROP_3(UpdateFunctionExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_CreateArrowFunctionExpression(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->CreateArrowFunctionExpression(context, node);
+ }
+ KOALA_INTEROP_2(CreateArrowFunctionExpression, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_ArrowFunctionExpressionFunction(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->ArrowFunctionExpressionFunction(context, node);
+ }
+ KOALA_INTEROP_2(ArrowFunctionExpressionFunction, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_ArrowFunctionExpressionCreateTypeAnnotation(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->ArrowFunctionExpressionCreateTypeAnnotation(context, node);
+ }
+ KOALA_INTEROP_2(ArrowFunctionExpressionCreateTypeAnnotation, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_FunctionExpressionFunction(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->FunctionExpressionFunction(context, node);
+ }
+ KOALA_INTEROP_2(FunctionExpressionFunction, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_ExpressionStatementGetExpression(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->ExpressionStatementGetExpression(context, node);
+ }
+ KOALA_INTEROP_2(ExpressionStatementGetExpression, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_CallExpressionArguments(KNativePointer contextPtr, KNativePointer nodePtr, KNativePointer returnLen) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     std::size_t params_len = 0;
+     auto params = GetImpl()->CallExpressionArguments(context, node, &params_len);
+     return new std::vector<void*>(params, params + params_len);
+ }
+ KOALA_INTEROP_3(CallExpressionArguments, KNativePointer, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_CallExpressionCallee(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     return GetImpl()->CallExpressionCallee(context, node);
+ }
+ KOALA_INTEROP_2(CallExpressionCallee, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_AstNodeParent(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     return GetImpl()->AstNodeParent(context, node);
+ }
+ KOALA_INTEROP_2(AstNodeParent, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_AstNodeVariableConst(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->AstNodeVariableConst(context, node);
+ }
+ KOALA_INTEROP_2(AstNodeVariableConst, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KInt impl_AstNodeTypeConst(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->AstNodeTypeConst(context, node);
+ }
+ KOALA_INTEROP_2(AstNodeTypeConst, KInt, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_VariableDeclaration(KNativePointer contextPtr, KNativePointer variablePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto variable = reinterpret_cast<es2panda_Variable*>(variablePtr);
+ 
+     return GetImpl()->VariableDeclaration(context, variable);
+ }
+ KOALA_INTEROP_2(VariableDeclaration, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_DeclNode(KNativePointer contextPtr, KNativePointer declPtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto decl = reinterpret_cast<es2panda_Declaration*>(declPtr);
+ 
+     return GetImpl()->DeclNode(context, decl);
+ }
+ KOALA_INTEROP_2(DeclNode, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_AstNodeScopeConst(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     return GetImpl()->AstNodeScopeConst(context, node);
+ }
+ KOALA_INTEROP_2(AstNodeScopeConst, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_ScopeSetParent(KNativePointer contextPtr, KNativePointer nodePtr, KNativePointer parentPtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_Scope*>(nodePtr);
+     auto parent = reinterpret_cast<es2panda_Scope*>(parentPtr);
+     GetImpl()->ScopeSetParent(context, node, parent);
+     return node;
+ }
+ KOALA_INTEROP_3(ScopeSetParent, KNativePointer, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_BlockStatementSetStatements(
+     KNativePointer contextPtr,
+     KNativePointer nodePtr,
+     KNativePointerArray statementsPtr,
+     KInt statementsLen
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     auto statements = reinterpret_cast<es2panda_AstNode**>(statementsPtr);
+ 
+     GetImpl()->BlockStatementSetStatements(context, node, statements, statementsLen);
+     return node;
+ }
+ KOALA_INTEROP_4(BlockStatementSetStatements, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KInt)
+ 
+ KNativePointer impl_VarBinderSetProgram(KNativePointer contextPtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+ 
+     GetImpl()->VarBinderSetProgram(context);
+     return nullptr;
+ }
+ KOALA_INTEROP_1(VarBinderSetProgram, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_VarBinderSetContext(KNativePointer contextPtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+ 
+     GetImpl()->VarBinderSetContext(context);
+     return nullptr;
+ }
+ KOALA_INTEROP_1(VarBinderSetContext, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_VarBinderSetGenStdLib(KNativePointer contextPtr, KBoolean genStdLibT) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto genStdLib = static_cast<bool>(genStdLibT);
+ 
+     GetImpl()->VarBinderSetGenStdLib(context, genStdLib);
+     return nullptr;
+ }
+ KOALA_INTEROP_2(VarBinderSetGenStdLib, KNativePointer, KNativePointer, KBoolean)
+ 
+ KNativePointer impl_CreateClassDeclaration(KNativePointer contextPtr, KNativePointer defPtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto def = reinterpret_cast<es2panda_AstNode*>(defPtr);
+ 
+     return GetImpl()->CreateClassDeclaration(context, def);
+ }
+ KOALA_INTEROP_2(CreateClassDeclaration, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_UpdateClassDeclaration(KNativePointer contextPtr, KNativePointer originalPtr, KNativePointer defPtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto original = reinterpret_cast<es2panda_AstNode*>(originalPtr);
+     auto def = reinterpret_cast<es2panda_AstNode*>(defPtr);
+ 
+     return GetImpl()->UpdateClassDeclaration(context, original, def);
+ }
+ KOALA_INTEROP_3(UpdateClassDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_ClassDefinitionSetTypeParams(
+     KNativePointer contextPtr,
+     KNativePointer nodePtr,
+     KNativePointer typeParamsPtr
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     auto typeParams = reinterpret_cast<es2panda_AstNode*>(typeParamsPtr);
+ 
+     GetImpl()->ClassDefinitionSetTypeParams(context, node, typeParams);
+     return node;
+ }
+ KOALA_INTEROP_3(ClassDefinitionSetTypeParams, KNativePointer, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_ClassDefinitionSetSuper(
+     KNativePointer contextPtr,
+     KNativePointer astPtr,
+     KNativePointer superClassPtr
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto ast = reinterpret_cast<es2panda_AstNode*>(astPtr);
+     auto superClass = reinterpret_cast<es2panda_AstNode*>(superClassPtr);
+ 
+     GetImpl()->ClassDefinitionSetSuper(context, ast, superClass);
+     return ast;
+ }
+ KOALA_INTEROP_3(ClassDefinitionSetSuper, KNativePointer, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_ClassDefinitionIdent(
+     KNativePointer contextPtr,
+     KNativePointer nodePtr
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->ClassDefinitionIdent(context, node);
+ }
+ KOALA_INTEROP_2(ClassDefinitionIdent, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_CreateClassDefinition1(
+     KNativePointer contextPtr,
+     KNativePointer identPtr,
+     KNativePointerArray bodyPtr,
+     KInt bodyLenT,
+     KInt modifiersT,
+     KInt flagsT
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto ident = reinterpret_cast<es2panda_AstNode*>(identPtr);
+     auto body = reinterpret_cast<es2panda_AstNode**>(bodyPtr);
+     auto bodyLen = static_cast<std::size_t>(bodyLenT);
+     auto modifiers = Es2pandaClassDefinitionModifiers(modifiersT);
+     auto flags = Es2pandaModifierFlags(flagsT);
+ 
+     return GetImpl()->CreateClassDefinition1(context, ident, body, bodyLen, modifiers, flags);
+ }
+ KOALA_INTEROP_6(CreateClassDefinition1, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KInt, KInt, KInt)
+ 
+ KNativePointer impl_UpdateClassDefinition1(
+     KNativePointer contextPtr,
+     KNativePointer originalPtr,
+     KNativePointer identPtr,
+     KNativePointerArray bodyPtr,
+     KInt bodyLenT,
+     KInt modifiersT,
+     KInt flagsT
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto original = reinterpret_cast<es2panda_AstNode*>(originalPtr);
+     auto ident = reinterpret_cast<es2panda_AstNode*>(identPtr);
+     auto body = reinterpret_cast<es2panda_AstNode**>(bodyPtr);
+     auto bodyLen = static_cast<std::size_t>(bodyLenT);
+     auto modifiers = Es2pandaClassDefinitionModifiers(modifiersT);
+     auto flags = Es2pandaModifierFlags(flagsT);
+ 
+     return GetImpl()->UpdateClassDefinition1(context, original, ident, body, bodyLen, modifiers, flags);
+ }
+ KOALA_INTEROP_7(UpdateClassDefinition1, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KInt, KInt, KInt)
+ 
+ KNativePointer impl_CreateSuperExpression(KNativePointer contextPtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+ 
+     return GetImpl()->CreateSuperExpression(context);
+ }
+ KOALA_INTEROP_1(CreateSuperExpression, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_UpdateSuperExpression(KNativePointer contextPtr, KNativePointer originalPtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto original = reinterpret_cast<es2panda_AstNode*>(originalPtr);
+ 
+     return GetImpl()->UpdateSuperExpression(context, original);
+ }
+ KOALA_INTEROP_2(UpdateSuperExpression, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_CreateETSImportDeclaration(
+     KNativePointer contextPtr,
+     KNativePointer sourcePtr,
+     KNativePointerArray specifiersPtr,
+     KInt specifiersLen,
+     KInt importKindT
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto source = reinterpret_cast<es2panda_ImportSource*>(sourcePtr);
+     auto specifiers = reinterpret_cast<es2panda_AstNode**>(specifiersPtr);
+     auto importKind = static_cast<Es2pandaImportKinds>(importKindT);
+ 
+     return GetImpl()->CreateETSImportDeclaration(context, source, specifiers, specifiersLen, importKind);
+ }
+ KOALA_INTEROP_5(CreateETSImportDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KInt, KInt)
+ 
+ KNativePointer impl_ETSImportDeclarationSourceConst(
+     KNativePointer contextPtr,
+     KNativePointer nodePtr
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->ETSImportDeclarationSourceConst(context, node);
+ }
+ KOALA_INTEROP_2(ETSImportDeclarationSourceConst, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_ETSImportDeclarationResolvedSource(
+     KNativePointer contextPtr,
+     KNativePointer nodePtr
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->ETSImportDeclarationResolvedSource(context, node);
+ }
+ KOALA_INTEROP_2(ETSImportDeclarationResolvedSource, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KBoolean impl_ETSImportDeclarationHasDeclConst(
+     KNativePointer contextPtr,
+     KNativePointer nodePtr
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+ 
+     return GetImpl()->ETSImportDeclarationHasDeclConst(context, node);
+ }
+ KOALA_INTEROP_2(ETSImportDeclarationHasDeclConst, KBoolean, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_CreateImportSource(
+     KNativePointer contextPtr,
+     KNativePointer sourcePtr,
+     KNativePointer resolvedSourcePtr,
+     KBoolean hasDeclT
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto source = reinterpret_cast<es2panda_AstNode*>(sourcePtr);
+     auto resolvedSource = reinterpret_cast<es2panda_AstNode*>(resolvedSourcePtr);
+     auto hasDecl = static_cast<bool>(hasDeclT);
+ 
+     return GetImpl()->CreateImportSource(context, source, resolvedSource, hasDecl);
+ }
+ KOALA_INTEROP_4(CreateImportSource, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KBoolean)
+ 
+ KNativePointer impl_CreateImportSpecifier(
+     KNativePointer contextPtr,
+     KNativePointer importedPtr,
+     KNativePointer localPtr
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto imported = reinterpret_cast<es2panda_AstNode*>(importedPtr);
+     auto local = reinterpret_cast<es2panda_AstNode*>(localPtr);
+ 
+     return GetImpl()->CreateImportSpecifier(context, imported, local);
+ }
+ KOALA_INTEROP_3(CreateImportSpecifier, KNativePointer, KNativePointer, KNativePointer, KNativePointer)
+ 
+ 
+ /*
+ TODO: NOT FROM API (shouldn't be there)
+ -----------------------------------------------------------------------------------------------------------------------------
+ */
+ 
+ es2panda_AstNode * __parentNode;
+ es2panda_Context * __context;
+ 
+ static void changeParent(es2panda_AstNode *child)
+ {
+     GetImpl()->AstNodeSetParent(__context, child, __parentNode);
+ }
+ 
+ static void SetRightParent(es2panda_AstNode *node, void *arg)
+ {
+     es2panda_Context *ctx = static_cast<es2panda_Context *>(arg);
+     __context = ctx;
+     __parentNode = node;
+ 
+     GetImpl()->AstNodeIterateConst(ctx, node, changeParent);
+ }
+ 
+ KNativePointer impl_AstNodeUpdateAll(KNativePointer contextPtr, KNativePointer programPtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto program = reinterpret_cast<es2panda_AstNode*>(programPtr);
+ 
+     GetImpl()->AstNodeForEach(program, SetRightParent, context);
+     return program;
+ }
+ KOALA_INTEROP_2(AstNodeUpdateAll, KNativePointer, KNativePointer, KNativePointer)
+ 
+ KNativePointer impl_AstNodeUpdateChildren(KNativePointer contextPtr, KNativePointer nodePtr) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     __parentNode = node;
+ 
+     GetImpl()->AstNodeIterateConst(context, node, changeParent);
+     return node;
+ }
+ KOALA_INTEROP_2(AstNodeUpdateChildren, KNativePointer, KNativePointer, KNativePointer)
+ 
+ std::vector<void*> __children;
+ 
+ static void visitChild(es2panda_AstNode *node) {
+     __children.emplace_back(node);
+ }
+ 
+ KNativePointer impl_AstNodeChildren(
+     KNativePointer contextPtr,
+     KNativePointer nodePtr
+ ) {
+     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
+     __context = context;
+     __children.clear();
+ 
+     GetImpl()->AstNodeIterateConst(context, node, visitChild);
+     return new std::vector(__children);
+ }
+ KOALA_INTEROP_2(AstNodeChildren, KNativePointer, KNativePointer, KNativePointer)
+ 
+ /*
+ -----------------------------------------------------------------------------------------------------------------------------
+ */
+ 
\ No newline at end of file
diff --git a/arkoala-arkts/libarkts/plugins/input/library.sts b/arkoala-arkts/libarkts/plugins/input/library.sts
index 9d7a1f0e13cbef43c547d3047989555cab2c8ef0..84aa6aac1e9833171a875dbc184d5761468fd98f 100644
--- a/arkoala-arkts/libarkts/plugins/input/library.sts
+++ b/arkoala-arkts/libarkts/plugins/input/library.sts
@@ -1 +1,3 @@
 export @interface Component {}
+
+export @interface memo {}
\ No newline at end of file
diff --git a/arkoala-arkts/libarkts/plugins/input/main.sts b/arkoala-arkts/libarkts/plugins/input/main.sts
index bff61711a10b1179cc5d2bb790e60205e1c1d937..0a64cf195fc7de11e24bc95a5909a3ef8ac76dc3 100644
--- a/arkoala-arkts/libarkts/plugins/input/main.sts
+++ b/arkoala-arkts/libarkts/plugins/input/main.sts
@@ -1,4 +1,4 @@
-import { Component } from "./library"
+import { Component, memo } from "./library"
 
 @interface BuilderLambda {
 	value: string
diff --git a/arkoala-arkts/libarkts/plugins/src/arkts-utils.ts b/arkoala-arkts/libarkts/plugins/src/arkts-utils.ts
new file mode 100644
index 0000000000000000000000000000000000000000..549790fd7ec1d9f633d429faaa47585ebd9e8238
--- /dev/null
+++ b/arkoala-arkts/libarkts/plugins/src/arkts-utils.ts
@@ -0,0 +1,28 @@
+import * as arkts from "@koalaui/libarkts"
+
+export function annotation(name: string): arkts.AnnotationUsageIr {
+    const ident: arkts.Identifier = arkts.factory.createIdentifier(name).setAnnotationUsage();
+    const annotation: arkts.AnnotationUsageIr = arkts.factory.createAnnotationUsageIr(ident);
+
+    annotation.modifiers = arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_ANNOTATION_USAGE;
+    ident.parent = annotation;
+
+    return annotation;
+}
+
+export function mangle(value: string): string {
+    return `__${value}`;
+}
+
+export function backingField(originalName: string): string {
+    return mangle(`backing_${originalName}`);
+}
+
+export function filterDefined<T>(value: (T | undefined)[]): T[] {
+    return value.filter((it: T | undefined): it is T => it != undefined);
+}
+
+export function collect<T>(...value: (ReadonlyArray<T> | T | undefined)[]): T[] {
+    const empty: (T | undefined)[] = []
+    return filterDefined(empty.concat(...value))
+}
diff --git a/arkoala-arkts/libarkts/plugins/src/builder-lambda-transformer.ts b/arkoala-arkts/libarkts/plugins/src/builder-lambda-transformer.ts
index 6be93bccdffd798db15b5b2012d3d0f0fb0c7cc7..e65728dba280c2f371ce5bfbd1883d5bbc9a83eb 100644
--- a/arkoala-arkts/libarkts/plugins/src/builder-lambda-transformer.ts
+++ b/arkoala-arkts/libarkts/plugins/src/builder-lambda-transformer.ts
@@ -31,7 +31,7 @@ function getLambdaArg(lambdaBody: arkts.AstNode, typeName: string|undefined): ar
         arkts.factory.createIdentifier(
             builderLambdaInstanceName,
             // TODO: it should be the return type of the function annotated with the @BuilderLambda
-            typeName ? arkts.factory.createTypeReference(
+            typeName ? arkts.factory.createTypeReferenceFromId(
                  arkts.factory.createIdentifier(
                      typeName
                  )
@@ -45,7 +45,7 @@ function getLambdaArg(lambdaBody: arkts.AstNode, typeName: string|undefined): ar
             param
         ],
         // TODO: it should be the return type of the function annotated with the @BuilderLambda
-        typeName ? arkts.factory.createTypeReference(
+        typeName ? arkts.factory.createTypeReferenceFromId(
             arkts.factory.createIdentifier(
                 typeName
             )
@@ -190,75 +190,142 @@ function builderLambdaReplace(leaf: arkts.CallExpression): arkts.Identifier|arkt
     return undefined
 }
 
-export class BuilderLambdaTransformer extends AbstractVisitor {
-    visitor(beforeChildren: arkts.AstNode): arkts.AstNode {
-        const node = this.visitEachChild(beforeChildren)
+function builderLambdaBodyRewrite(node: arkts.AstNode): arkts.AstNode {
+    if (!arkts.isArrowFunctionExpression(node)) return node;
 
-        if (!arkts.isCallExpression(node)) {
-            return node
-        }
+    const scriptFunc: arkts.ScriptFunction = node.scriptFunction;
+    if (!scriptFunc || !scriptFunc.body) return node;
 
-        if (true
-            && arkts.isMemberExpression(node.parent)
-            && arkts.isIdentifier(node.parent.property)
-            && arkts.isCallExpression(node.parent.parent)
+    const body: arkts.BlockStatement = scriptFunc.body;
+    const statements: arkts.AstNode[] = body.statements.map((statement: arkts.AstNode) => {
+        if (
+            arkts.isExpressionStatement(statement) 
+            && statement.expression 
+            && arkts.isCallExpression(statement.expression)
         ) {
-            return node
+            return transformBuilderLambda(statement.expression);
         }
+        return statement;
+    }); 
+    const updateBody = arkts.factory.updateBlock(body, statements);
+
+    const signature: arkts.FunctionSignature = arkts.FunctionSignature.create(undefined, [], undefined);
+    const updateFunc: arkts.ScriptFunction = arkts.factory.updateScriptFunction(
+        scriptFunc, 
+        updateBody, 
+        signature, // TODO: Cannot get signature from original ScriptFunction node
+        scriptFunc.scriptFunctionFlags,
+        scriptFunc.modifiers,
+        false,
+        undefined
+    );
 
-        let instanceCalls: arkts.CallExpression[] = []
-        let leaf: arkts.CallExpression = node
+    return arkts.factory.updateArrowFunction(node, updateFunc);
+}
 
-        while (true
-            && arkts.isMemberExpression(leaf.expression)
-            && arkts.isIdentifier(leaf.expression.property)
-            && arkts.isCallExpression(leaf.expression.object)
-        ) {
-            instanceCalls.push(
-                arkts.factory.createCallExpression(
-                    leaf.expression.property,
-                    undefined,
-                    leaf.arguments
-                )
-            )
-            leaf = leaf.expression.object
-        }
+function transformBuilderLambda(node: arkts.CallExpression): arkts.AstNode {
+    let instanceCalls: arkts.CallExpression[] = []
+    let leaf: arkts.CallExpression = node
 
-		const replace = builderLambdaReplace(leaf)
-		if (replace === undefined) {
-			return node
-		}
-
-        instanceCalls = instanceCalls.reverse()
-        let lambdaBody: arkts.Identifier | arkts.CallExpression = arkts.factory.createIdentifier(builderLambdaInstanceName)
-        instanceCalls.forEach((call)=> {
-            if (!arkts.isIdentifier(call.expression)) {
-                throw new Error('call expression should be identifier')
-            }
-            lambdaBody = arkts.factory.createCallExpression(
-                arkts.factory.createMemberExpression(
-                    lambdaBody,
-                    call.expression,
-                    arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS,
-                    false,
-                    false
-                ),
+    while (true
+        && arkts.isMemberExpression(leaf.expression)
+        && arkts.isIdentifier(leaf.expression.property)
+        && arkts.isCallExpression(leaf.expression.object)
+    ) {
+        instanceCalls.push(
+            arkts.factory.createCallExpression(
+                leaf.expression.property,
                 undefined,
-                call.arguments
+                leaf.arguments
             )
-        })
+        )
+        leaf = leaf.expression.object
+    }
 
-        const typeName = builderLambdaTypeName(leaf)
-        const lambdaArg = getLambdaArg(lambdaBody, typeName)
+    const replace = builderLambdaReplace(leaf)
+    if (replace === undefined) {
+        return node
+    }
 
-        return arkts.factory.updateCallExpression(
-            node,
-			replace,
+    instanceCalls = instanceCalls.reverse()
+    let lambdaBody: arkts.Identifier | arkts.CallExpression = arkts.factory.createIdentifier(builderLambdaInstanceName)
+    instanceCalls.forEach((call)=> {
+        if (!arkts.isIdentifier(call.expression)) {
+            throw new Error('call expression should be identifier')
+        }
+        lambdaBody = arkts.factory.createCallExpression(
+            arkts.factory.createMemberExpression(
+                lambdaBody,
+                call.expression,
+                arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS,
+                false,
+                false
+            ),
             undefined,
-            [
-                lambdaArg,
-                ...leaf.arguments
-            ]
+            call.arguments
         )
+    })
+
+    const typeName = builderLambdaTypeName(leaf)
+    const lambdaArg = getLambdaArg(lambdaBody, typeName)
+
+    let args: arkts.AstNode[] = leaf.arguments.length < 3 
+        ? leaf.arguments as arkts.AstNode[]
+        : [
+            ...leaf.arguments.slice(0, 2), 
+            builderLambdaBodyRewrite(leaf.arguments.at(2)!), 
+            ...leaf.arguments.slice(3) // Currently, this is never reached since the maximum length of arguments is 3
+        ];
+
+    return arkts.factory.updateCallExpression(
+        node,
+        replace,
+        undefined,
+        [
+            lambdaArg,
+            ...args
+        ]
+    )
+}
+
+function isBuilderLambda(node: arkts.AstNode): boolean {
+    const builderLambda: arkts.AstNode | undefined = _getDeclForBuilderLambda(node);
+    return !!builderLambda;
+}
+
+// TODO: temporary solution for get declaration of a builder lambda
+function _getDeclForBuilderLambda(node: arkts.AstNode): arkts.AstNode | undefined {
+    if (!node || !arkts.isCallExpression(node)) return undefined;
+
+    if (node.expression && arkts.isMemberExpression(node.expression)) {
+        const _node: arkts.MemberExpression = node.expression;
+        if (_node.property && arkts.isIdentifier(_node.property) && _node.property.name === "$_instantiate") {
+            return node;
+        }
+        if (_node.object && arkts.isCallExpression(_node.object)) {
+            return _getDeclForBuilderLambda(_node.object);
+        }
+    }
+
+    return undefined;
+}
+
+export class BuilderLambdaTransformer extends AbstractVisitor {
+    visitEachChild(node: arkts.AstNode): arkts.AstNode {
+        if (arkts.isCallExpression(node) && isBuilderLambda(node)) {
+            return node;
+        }
+
+        return super.visitEachChild(node);
+    }
+
+    visitor(beforeChildren: arkts.AstNode): arkts.AstNode {
+        const node = this.visitEachChild(beforeChildren)
+
+        if (arkts.isCallExpression(node) && isBuilderLambda(node)) {
+            return transformBuilderLambda(node);
+        }
+
+        return node;
     }
 }
diff --git a/arkoala-arkts/libarkts/plugins/src/checked-stage-plugin.ts b/arkoala-arkts/libarkts/plugins/src/checked-stage-plugin.ts
index ec0578ffde3afe67fb6a161e67b9d9e6a0123bfb..d162d1f3f4606018a88101373aa97511c4d458d1 100644
--- a/arkoala-arkts/libarkts/plugins/src/checked-stage-plugin.ts
+++ b/arkoala-arkts/libarkts/plugins/src/checked-stage-plugin.ts
@@ -1,7 +1,10 @@
 import * as ts from "@koalaui/libarkts"
-import { PrintVisitor } from './print-visitor'
 import { BuilderLambdaTransformer } from './builder-lambda-transformer'
-import { ComponentTransformer } from './component-transformer'
+import { StructTransformer } from './struct-transformer'
+import { PositionalIdTracker } from "./utils"
+import { ImportTransformer } from "./import-transformer"
+import { FunctionTransformer } from "./function-transformer"
+import { TestTransformer } from "./only-test-transformer"
 
 export interface TransformerOptions {
     trace?: boolean,
@@ -11,6 +14,23 @@ export default function exampleTransformer(
     userPluginOptions?: TransformerOptions
 ) {
     return (node: ts.EtsScript) => {
-        return new BuilderLambdaTransformer().visitor(node)
+        const builderLambdaTransformer = new BuilderLambdaTransformer();
+        const structTransformer = new StructTransformer();
+
+        let script: ts.EtsScript = node;
+        script = builderLambdaTransformer.visitor(script) as ts.EtsScript;
+        script = structTransformer.visitor(script) as ts.EtsScript;
+
+        const positionalIdTracker = new PositionalIdTracker(ts.getFileName(), false);
+        const importTransformer = new ImportTransformer();
+        const functionTransformer = new FunctionTransformer(positionalIdTracker);
+        importTransformer.visitor(script);
+        script = functionTransformer.visitor(script) as ts.EtsScript;
+
+        // TODO: remove this when the .d.ets transformation is ready
+        const testTransformer = new TestTransformer();
+        script = testTransformer.visitor(script) as ts.EtsScript;
+
+        return script;
     }
 }
diff --git a/arkoala-arkts/libarkts/plugins/src/component-transformer.ts b/arkoala-arkts/libarkts/plugins/src/component-transformer.ts
index eb9dea77434d7c2286f31896f1a5a76c4137f03d..10b2a6d0eafd7699766fdf15693bd79e51ec6a6a 100644
--- a/arkoala-arkts/libarkts/plugins/src/component-transformer.ts
+++ b/arkoala-arkts/libarkts/plugins/src/component-transformer.ts
@@ -71,6 +71,7 @@ export class ComponentTransformer extends AbstractVisitor {
 
     processComponent(node: arkts.ClassDeclaration | arkts.StructDeclaration): arkts.ClassDeclaration {
         const className = node.definition.name.name
+        arkts.GlobalInfo.getInfoInstance().add(className);
         this.context.componentNames.push(className)
 
         const newDefinition = arkts.factory.updateClassDefinition(
@@ -85,10 +86,10 @@ export class ComponentTransformer extends AbstractVisitor {
                     arkts.factory.createIdentifier('StructBase'),
                     arkts.factory.createTSTypeParameterInstantiation(
                         [
-                            arkts.factory.createTypeReference(
+                            arkts.factory.createTypeReferenceFromId(
                                 arkts.factory.createIdentifier(className)
                             ),
-                            arkts.factory.createTypeReference(
+                            arkts.factory.createTypeReferenceFromId(
                                 arkts.factory.createIdentifier(`__Options_${className}`)
                             ),
                         ]
diff --git a/arkoala-arkts/libarkts/plugins/src/function-transformer.ts b/arkoala-arkts/libarkts/plugins/src/function-transformer.ts
index b6b77810be3f77abd7c388875e6e87d9c2dbe14b..9cb7e31657bf9f4fb54411c006b90b9d6fb599ea 100644
--- a/arkoala-arkts/libarkts/plugins/src/function-transformer.ts
+++ b/arkoala-arkts/libarkts/plugins/src/function-transformer.ts
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
+ * Copyright (c) 2022-2025 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
@@ -13,85 +13,151 @@
  * limitations under the License.
  */
 
-import * as ts from "@koalaui/libarkts"
-import { AbstractVisitor } from "./AbstractVisitor";
+import * as arkts from "@koalaui/libarkts"
+import { AbstractVisitor } from "./AbstractVisitor"
+import { createContextParameter, createIdParameter, createContextArgument, createIdArgument, RuntimeNames, PositionalIdTracker } from "./utils"
 
-const ANNOTATION = "_REWRITE_"
+function isMemoAnnotation(anno: arkts.AnnotationUsageIr): boolean {
+    return arkts.isIdentifier(anno.expr) && anno.expr.name === RuntimeNames.ANNOTATION;
+}
 
-function isAnnotatedCallExpression(node: ts.Node): boolean {
-    return ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text.startsWith(ANNOTATION)
+function hasMemoAnnotation(node: arkts.ScriptFunction) {
+    return node.annotations.some(isMemoAnnotation);
 }
 
-function isAnnotatedMethodDeclaration(node: ts.Node): boolean {
-    return ts.isMethodDeclaration(node) && node.name.text.startsWith(ANNOTATION)
+function removeMemoAnnotationInParam(param: arkts.ETSParameterExpression): arkts.ETSParameterExpression {
+    param.annotations = param.annotations.filter((it) => !isMemoAnnotation(it));
+    return param;
 }
 
-function transformCallExpression(node: ts.CallExpression): ts.Node {
-    const decl = ts.getDecl(node.expression)
-    if (decl === undefined) {
-        throw new Error('memo function for call not found')
-    }
-    if (!ts.isIdentifier(node.expression)) {
-        throw new Error('expression should be Identifier')
-    }
+function createHiddenParameters(): arkts.ETSParameterExpression[] {
+    return [createContextParameter(), createIdParameter()]
+}
 
-    return ts.factory.updateCallExpression(
-        node,
-        ts.factory.createIdentifier(
-            node.expression.text.slice(ANNOTATION.length)
-        ),
-        undefined,
+function createHiddenArguments(hash: arkts.NumberLiteral | arkts.StringLiteral): arkts.AstNode[] {
+    return [createContextArgument(), createIdArgument(hash)]
+}
+
+function updateFunctionBody(node: arkts.BlockStatement | undefined, hash: arkts.NumberLiteral | arkts.StringLiteral): arkts.BlockStatement | undefined {
+    if (node === undefined)
+        return node
+    const scopeDeclaraion = arkts.factory.createVariableDeclaration(
+        0,
+        arkts.Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_CONST,
         [
-            ts.factory.createStringLiteral("SAMPLE"),
-            ...node.arguments
+            arkts.factory.createVariableDeclarator(
+                arkts.Es2pandaVariableDeclaratorFlag.VARIABLE_DECLARATOR_FLAG_CONST,
+                arkts.factory.createIdentifier(RuntimeNames.SCOPE),
+                arkts.factory.createCallExpression(
+                    arkts.factory.createMemberExpression(
+                        arkts.factory.createIdentifier(RuntimeNames.CONTEXT),
+                        arkts.factory.createIdentifier(RuntimeNames.INTERNAL_SCOPE),
+                        arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS,
+                        false,
+                        false
+                    ),
+                    arkts.factory.createTSTypeParameterInstantiation(
+                        [
+                            arkts.factory.createTypeReferenceFromId(
+                                arkts.factory.createIdentifier("void")
+                            )
+                        ]
+                    ),
+                    [
+                        createIdArgument(hash)
+                    ]
+                )
+            )
         ]
     )
-}
-
-function transformMethodDeclaration(node: ts.MethodDeclaration): ts.Node {
-    const stringParam =
-        ts.factory.createParameterDeclaration(
-            undefined,
-            undefined,
-            ts.factory.createIdentifier("x"),
+    const unchangedCheck = arkts.factory.createIfStatement(
+        arkts.factory.createMemberExpression(
+            arkts.factory.createIdentifier(RuntimeNames.SCOPE),
+            arkts.factory.createIdentifier(RuntimeNames.INTERNAL_VALUE_OK),
+            arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_NONE,
+            false,
+            false
+        ),
+        arkts.factory.createReturnStatement(
+            arkts.factory.createMemberExpression(
+                arkts.factory.createIdentifier(RuntimeNames.SCOPE),
+                arkts.factory.createIdentifier(RuntimeNames.INTERNAL_VALUE),
+                arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_NONE,
+                false,
+                false
+            )
+        )
+    )
+    const recache = arkts.factory.createReturnStatement(
+        arkts.factory.createCallExpression(
+            arkts.factory.createMemberExpression(
+                arkts.factory.createIdentifier(RuntimeNames.SCOPE),
+                arkts.factory.createIdentifier(RuntimeNames.INTERNAL_VALUE_NEW),
+                arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS,
+                false,
+                false
+            ),
             undefined,
-            ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
-            undefined
+            []
         )
-    return ts.factory.updateMethodDeclaration(
+    )
+    return arkts.factory.updateBlock(
         node,
-        undefined,
-        undefined,
-        ts.factory.createIdentifier(
-            node.name.text.slice(ANNOTATION.length)
-        ),
-        undefined,
-        undefined,
         [
-            stringParam,
-            ...node.parameters
-        ],
-        undefined,
-        node.body,
+            scopeDeclaraion,
+            unchangedCheck,
+            ...node.statements,
+            recache
+        ]
     )
 }
 
+function transformMemoMethod(method: arkts.MethodDefinition, positionalIdTracker: PositionalIdTracker): arkts.MethodDefinition {
+    const key: arkts.Identifier = method.name;
+    const scriptFunction: arkts.ScriptFunction = method.scriptFunction;
+
+    const updateScriptFunction = arkts.factory.createScriptFunction(
+        updateFunctionBody(scriptFunction.body, positionalIdTracker.id(key.name)),
+        undefined,
+        scriptFunction.scriptFunctionFlags,
+        scriptFunction.modifiers,
+        false,
+        scriptFunction.ident,
+        [...createHiddenParameters(), ...scriptFunction.parameters.map(removeMemoAnnotationInParam)]
+    );
+
+    return arkts.factory.createMethodDefinition(
+        arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_METHOD,
+        key,
+        arkts.factory.createFunctionExpression(updateScriptFunction),
+        method.modifiers,
+        false
+    );
+}
+
 export class FunctionTransformer extends AbstractVisitor {
-    constructor(
-        ctx?: ts.TransformationContext
-    ) {
-        super(ctx)
+    constructor(private positionalIdTracker: PositionalIdTracker) {
+        super()
     }
 
-    visitor(beforeChildren: ts.Node): ts.Node {
-        const node: ts.Node = this.visitEachChild(beforeChildren)
+    visitor(beforeChildren: arkts.AstNode): arkts.AstNode {
+        const node = this.visitEachChild(beforeChildren);
 
-        if (isAnnotatedMethodDeclaration(node) && ts.isMethodDeclaration(node)) {
-            return transformMethodDeclaration(node)
-        } else if (isAnnotatedCallExpression(node) && ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
-            return transformCallExpression(node)
+        if (arkts.isMethodDefinition(node) && hasMemoAnnotation(node.scriptFunction)) {
+            return transformMemoMethod(node, this.positionalIdTracker);
+        }
+        if (node instanceof arkts.CallExpression) {
+            const expr = node.expression
+            const decl = arkts.getDecl(expr)
+            if (decl instanceof arkts.MethodDefinition && hasMemoAnnotation(decl.scriptFunction)) {
+                return arkts.factory.updateCallExpression(
+                    node,
+                    node.expression,
+                    undefined,
+                    [...createHiddenArguments(this.positionalIdTracker.id(decl.name.name)), ...node.arguments]
+                )
+            }
         }
-
         return node
     }
 }
diff --git a/arkoala-arkts/libarkts/plugins/src/import-transformer.ts b/arkoala-arkts/libarkts/plugins/src/import-transformer.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4037bcf65925b2c390206004259a29a62b21840b
--- /dev/null
+++ b/arkoala-arkts/libarkts/plugins/src/import-transformer.ts
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2022-2025 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 arkts from "@koalaui/libarkts"
+import { AbstractVisitor } from "./AbstractVisitor"
+import { createContextTypeImportSpecifier, createIdTypeImportSpecifier, RuntimeNames } from "./utils"
+
+function createContextTypesImportDeclaration(): arkts.EtsImportDeclaration {
+    return arkts.factory.createImportDeclaration(
+        arkts.factory.createStringLiteral(RuntimeNames.CONTEXT_TYPE_DEFAULT_IMPORT),
+        [createContextTypeImportSpecifier(), createIdTypeImportSpecifier()],
+        arkts.Es2pandaImportKinds.IMPORT_KINDS_TYPE,
+        true,
+    )
+}
+
+export class ImportTransformer extends AbstractVisitor {
+    visitor(node: arkts.AstNode): arkts.AstNode {
+        if (node instanceof arkts.EtsScript) {
+            return arkts.factory.updateEtsScript(
+                node,
+                [
+                    ...node.getChildren().filter(it => it instanceof arkts.EtsImportDeclaration),
+                    createContextTypesImportDeclaration(),
+                    ...node.getChildren().filter(it => !(it instanceof arkts.EtsImportDeclaration)),
+                ]
+            )
+        }
+        return node
+    }
+}
diff --git a/arkoala-arkts/libarkts/plugins/src/index.ts b/arkoala-arkts/libarkts/plugins/src/index.ts
new file mode 100644
index 0000000000000000000000000000000000000000..975098dcf845209e9604f567cc283f30aeb9aac9
--- /dev/null
+++ b/arkoala-arkts/libarkts/plugins/src/index.ts
@@ -0,0 +1,71 @@
+import * as ts from "@koalaui/libarkts"
+import { ComponentTransformer, ComponentTransformerOptions } from './component-transformer'
+import { BuilderLambdaTransformer } from './builder-lambda-transformer'
+import { StructTransformer } from './struct-transformer'
+import { PositionalIdTracker } from "./utils";
+import { ImportTransformer } from "./import-transformer";
+import { FunctionTransformer } from "./function-transformer";
+import { TestTransformer } from "./only-test-transformer";
+
+// TODO: move this to arkts-api
+class PluginContext {
+  private ast: ts.EtsScript | undefined;
+
+  constructor() {
+    this.ast = undefined;
+  }
+
+  public setArkTSAst(ast: ts.EtsScript): void {
+    this.ast = ast;
+  }
+
+  public getArkTSAst(): ts.EtsScript | undefined {
+    return this.ast;
+  }
+}
+
+export function koalaUITransform() {
+    return {
+        name: 'ArkUI',
+        parsed(this: PluginContext) {
+            console.log("In ArkUI afterParsed")
+            const node = this.getArkTSAst();
+            if (node) {
+                let script: ts.EtsScript = node;
+                script = new ComponentTransformer({ arkui: "@ohos.arkui" }).visitor(node) as ts.EtsScript;
+                ts.setAllParents(script);
+                this.setArkTSAst(script);
+                return script;
+            }
+        },
+        checked(this: PluginContext) {
+            console.log("In ArkUI afterChecked")
+            const node = this.getArkTSAst();
+            if (node) {
+                const builderLambdaTransformer = new BuilderLambdaTransformer();
+                const structTransformer = new StructTransformer();
+                const importTransformer = new ImportTransformer();
+
+                let script: ts.EtsScript = node;
+                importTransformer.visitor(script);
+                script = builderLambdaTransformer.visitor(script) as ts.EtsScript;
+                script = structTransformer.visitor(script) as ts.EtsScript;
+
+                const positionalIdTracker = new PositionalIdTracker(ts.getFileName(), false);
+                const functionTransformer = new FunctionTransformer(positionalIdTracker);
+                script = functionTransformer.visitor(script) as ts.EtsScript;
+
+                // TODO: remove this when the .d.ets transformation is ready
+                const testTransformer = new TestTransformer();
+                script = testTransformer.visitor(script) as ts.EtsScript;
+
+                ts.setAllParents(script);
+                this.setArkTSAst(script);
+                return script;
+            }
+        },
+        clean(this: PluginContext) {
+            console.log("In ArkUI clean")
+        }
+    }
+}
\ No newline at end of file
diff --git a/arkoala-arkts/libarkts/plugins/src/memo-transformer.ts b/arkoala-arkts/libarkts/plugins/src/memo-transformer.ts
index 01a2451714fb1bf7e0a7678d59f92c6bda34a877..02c8d3a6a3f180f0db03d055e47bad7c981cd236 100644
--- a/arkoala-arkts/libarkts/plugins/src/memo-transformer.ts
+++ b/arkoala-arkts/libarkts/plugins/src/memo-transformer.ts
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
+ * Copyright (c) 2022-2025 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
@@ -13,143 +13,23 @@
  * limitations under the License.
  */
 
-import * as ts from "@koalaui/libarkts"
-import { AbstractVisitor } from "./AbstractVisitor";
+import * as arkts from "@koalaui/libarkts"
+import { FunctionTransformer } from "./function-transformer"
+import { ImportTransformer } from "./import-transformer"
+import { PositionalIdTracker } from "./utils"
 
-const ANNOTATION = "_MEMO_"
-
-function isAnnotatedCallExpression(node: ts.Node): boolean {
-    return ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text.startsWith(ANNOTATION)
-}
-
-function isAnnotatedMethodDeclaration(node: ts.Node): boolean {
-    return ts.isMethodDeclaration(node) && node.name.text.startsWith(ANNOTATION)
-}
-
-function transformCallExpression(node: ts.CallExpression): ts.Node {
-    const decl = ts.getDecl(node.expression)
-    if (decl === undefined) {
-        throw new Error('memo function not found')
-    }
-    if (!ts.isIdentifier(node.expression)) {
-        throw new Error('expression should be Identifier')
-    }
-
-    return ts.factory.updateCallExpression(
-        node,
-        ts.factory.createIdentifier(
-            node.expression.text.slice(ANNOTATION.length)
-        ),
-        undefined,
-        [
-            ts.factory.createIdentifier("__memo_context"),
-            ts.factory.createIdentifier("__memo_id"),
-            ...node.arguments
-        ]
-    )
-}
-
-function transformMethodDeclaration(node: ts.MethodDeclaration): ts.Node {
-    const memoContextParam =
-        ts.factory.createParameterDeclaration(
-            undefined,
-            undefined,
-            ts.factory.createIdentifier("__memo_context"),
-            undefined,
-            ts.factory.createTypeReferenceNode(
-                ts.factory.createIdentifier("__memo_context_type")
-            ),
-            undefined
-        )
-    const memoIdParam =
-        ts.factory.createParameterDeclaration(
-            undefined,
-            undefined,
-            ts.factory.createIdentifier("__memo_id"),
-            undefined,
-            ts.factory.createTypeReferenceNode(
-                ts.factory.createIdentifier("__memo_id_type")
-            ),
-            undefined
-        )
-    const bodyStatements = [
-        ts.factory.createIfStatement(
-            ts.factory.createPropertyAccessExpression(
-                ts.factory.createIdentifier("__memo_scope"),
-                ts.factory.createIdentifier("unchanged")
-            ),
-            ts.factory.createReturnStatement(
-                ts.factory.createPropertyAccessExpression(
-                    ts.factory.createIdentifier("__memo_scope"),
-                    ts.factory.createIdentifier("cached")
-                )
-            ),
-            undefined
-        ),
-        ts.factory.createExpressionStatement(
-            ts.factory.createCallExpression(
-                ts.factory.createIdentifier("content"),
-                undefined,
-                [
-                ts.factory.createIdentifier("__memo_context"),
-                ts.factory.createBinaryExpression(
-                    ts.factory.createIdentifier("__memo_id"),
-                    ts.factory.createToken(ts.SyntaxKind.PlusToken),
-                    ts.factory.createStringLiteral("key_id_main.ts")
-                )
-                ]
-        )),
-        ...(node.body?.statements ?? []),
-        ts.factory.createReturnStatement(
-            ts.factory.createCallExpression(
-                ts.factory.createPropertyAccessExpression(
-                    ts.factory.createIdentifier("__memo_scope"),
-                    ts.factory.createIdentifier("recache")
-                ),
-                undefined,
-                undefined
-            )
-        ),
-    ]
-    return ts.factory.updateMethodDeclaration(
-        node,
-        undefined,
-        undefined,
-        ts.factory.createIdentifier(
-            node.name.text.slice(ANNOTATION.length)
-        ),
-        undefined,
-        undefined,
-        [
-            memoContextParam,
-            memoIdParam,
-            ...node.parameters
-        ],
-        undefined,
-        node.body ?
-        ts.factory.updateBlock(
-            node.body,
-            bodyStatements
-        ) : undefined
-    )
+export interface TransformerOptions {
+    trace?: boolean,
 }
 
-export class MemoTransformer extends AbstractVisitor {
-    constructor(
-        ctx?: ts.TransformationContext
-    ) {
-        super(ctx)
-    }
-
-    visitor(beforeChildren: ts.Node): ts.Node {
-        const node: ts.Node = this.visitEachChild(beforeChildren)
-
-        if (isAnnotatedMethodDeclaration(node) && ts.isMethodDeclaration(node)) {
-            return transformMethodDeclaration(node)
-        } else if (isAnnotatedCallExpression(node) && ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
-            return transformCallExpression(node)
-        }
-
-        return node
+export default function memoTransformer(
+    userPluginOptions?: TransformerOptions
+) {
+    return (node: arkts.EtsScript) => {
+        const positionalIdTracker = new PositionalIdTracker(arkts.getFileName(), false)
+        const importTransformer = new ImportTransformer()
+        const functionTransformer = new FunctionTransformer(positionalIdTracker)
+        importTransformer.visitor(node)
+        return functionTransformer.visitor(node)
     }
 }
diff --git a/arkoala-arkts/libarkts/plugins/src/only-test-transformer.ts b/arkoala-arkts/libarkts/plugins/src/only-test-transformer.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9b6c67e7068c862eb7e206739a98cb1cbfd3559f
--- /dev/null
+++ b/arkoala-arkts/libarkts/plugins/src/only-test-transformer.ts
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2022-2025 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 arkts from "@koalaui/libarkts"
+import { AbstractVisitor } from "./AbstractVisitor"
+
+export class TestTransformer extends AbstractVisitor {
+    visitor(beforeChildren: arkts.AstNode): arkts.AstNode {
+        const node = this.visitEachChild(beforeChildren);
+
+        // This is only for testing purpose. Now the .d.ets transformation is not ready,
+        // there are @ohos.arkui and @ohos.arkui.after.check, the former one is for transformation before checked,
+        // the later one is for transformation after checked.
+        if (arkts.isEtsImportDeclaration(node) && node.importSource.str === "@ohos.arkui") {
+            const source = node.importSource;
+            return arkts.factory.updateImportDeclaration(
+                node,
+                arkts.factory.updateStringLiteral(
+                    source,
+                    "@ohos.arkui.after.check"
+                ),
+                node.importSpecifiers,
+                node.importKind,
+                node.hasDecl
+            );
+        }
+
+        return node
+    }
+}
diff --git a/arkoala-arkts/libarkts/plugins/src/struct-transformer.ts b/arkoala-arkts/libarkts/plugins/src/struct-transformer.ts
new file mode 100644
index 0000000000000000000000000000000000000000..41d9a33d6975169bf6f5314cabd06cfd2e890303
--- /dev/null
+++ b/arkoala-arkts/libarkts/plugins/src/struct-transformer.ts
@@ -0,0 +1,182 @@
+import * as arkts from "@koalaui/libarkts"
+import { AbstractVisitor } from "./AbstractVisitor";
+import { annotation } from "./arkts-utils";
+
+function isCustomComponentClass(node: arkts.ClassDeclaration): boolean {
+    const structCollection: Set<string> = arkts.GlobalInfo.getInfoInstance().getStructCollection();
+    if (structCollection.has(node.definition.name.name)) {
+        return true;
+    }
+    return false;
+}
+
+function isKnownMethodDefinition(method: arkts.MethodDefinition, name: string): boolean {
+    if (!method || !arkts.isMethodDefinition(method)) return false;
+
+    // For now, we only considered matched method name.
+    const isNameMatched: boolean = method.name?.name === name;
+    return isNameMatched;
+}
+
+function createStyleArgInBuildMethod(className: string): arkts.ETSParameterExpression {
+    const styleLambdaParams: arkts.ETSParameterExpression = arkts.factory.createParameterDeclaration(
+        arkts.factory.createIdentifier(
+            'instance',
+            arkts.factory.createIdentifier(className),
+        ),
+        undefined
+    );
+
+    const styleLambda: arkts.ETSFunctionType = arkts.factory.createFunctionType(
+        arkts.FunctionSignature.create(
+            undefined,
+            [
+                styleLambdaParams
+            ],
+            arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID)
+        ),
+        arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_ARROW
+    );
+
+    const optionalStyleLambda: arkts.ETSUnionType = arkts.factory.createUnionType([
+        styleLambda,
+        arkts.factory.createUndefinedLiteral()
+    ]);
+
+    const styleParam: arkts.Identifier = arkts.factory.createIdentifier(
+        'style',
+        optionalStyleLambda
+    );
+
+    const param = arkts.factory.createParameterDeclaration(styleParam, undefined);
+    param.annotations = [annotation("memo")];
+
+    return param;
+}
+
+function createContentArgInBuildMethod(): arkts.ETSParameterExpression {
+    const contentLambda: arkts.ETSFunctionType = arkts.factory.createFunctionType(
+        arkts.FunctionSignature.create(
+            undefined,
+            [],
+            arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID)
+        ),
+        arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_ARROW
+    );
+
+    const optionalContentLambda: arkts.ETSUnionType = arkts.factory.createUnionType([
+        contentLambda,
+        arkts.factory.createUndefinedLiteral()
+    ]);
+
+    const contentParam: arkts.Identifier = arkts.factory.createIdentifier(
+        'content',
+        optionalContentLambda
+    );
+
+    const param = arkts.factory.createParameterDeclaration(contentParam, undefined);
+    param.annotations = [annotation("memo")];
+
+    return param;
+}
+
+function createInitializerArgInBuildMethod(className: string): arkts.ETSParameterExpression {
+    return arkts.factory.createParameterDeclaration(
+        arkts.factory.createIdentifier(
+            'initializers',
+            arkts.factory.createTypeReferenceFromId(
+                arkts.factory.createIdentifier(`__Options_${className}`)
+            )
+        ).setOptional(true),
+        undefined
+    );
+}
+
+function prepareArgsInBuildMethod(className: string): arkts.ETSParameterExpression[] {
+    return [
+        createStyleArgInBuildMethod(className),
+        createContentArgInBuildMethod(),
+        createInitializerArgInBuildMethod(className)
+    ];
+}
+
+function transformBuildMethod(
+    method: arkts.MethodDefinition,
+    className: string
+): arkts.MethodDefinition {
+    const updateKey: arkts.Identifier = arkts.factory.createIdentifier(
+        '_build'
+    );
+
+    const scriptFunction: arkts.ScriptFunction = method.scriptFunction;
+
+    const params: arkts.ETSParameterExpression[] = prepareArgsInBuildMethod(className);
+
+    const signature: arkts.FunctionSignature = arkts.FunctionSignature.create(
+        undefined,
+        params,
+        undefined
+    );
+    const updateScriptFunction = arkts.factory.createScriptFunction(
+        scriptFunction.body,
+        signature,
+        scriptFunction.scriptFunctionFlags,
+        scriptFunction.modifiers,
+        false,
+        undefined
+    );
+
+    updateScriptFunction.annotations = [annotation("memo")];
+
+    return arkts.factory.createMethodDefinition(
+        arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_METHOD,
+        updateKey,
+        arkts.factory.createFunctionExpression(updateScriptFunction),
+        arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PROTECTED,
+        false
+    );
+}
+
+function tranformClassMembers(node: arkts.ClassDeclaration): arkts.ClassDeclaration {
+    const definition: arkts.ClassDefinition = node.definition;
+    const className: string = node.definition.name.name;
+
+    const updateMembers: arkts.AstNode[] = definition.members.map((member: arkts.AstNode) => {
+        if (arkts.isMethodDefinition(member) && isKnownMethodDefinition(member, "constructor")) {
+            return arkts.factory.createMethodDefinition(
+                arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_CONSTRUCTOR,
+                member.name,
+                arkts.factory.createFunctionExpression(member.scriptFunction),
+                arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_CONSTRUCTOR,
+                false
+            );
+        }
+        if (arkts.isMethodDefinition(member) && isKnownMethodDefinition(member, "build")) {
+            return transformBuildMethod(member, className);
+        }
+
+        return member;
+    });
+
+    const updateClassDef: arkts.ClassDefinition = arkts.factory.updateClassDefinition(
+        definition,
+        definition.name,
+        updateMembers,
+        definition.modifiers,
+        arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE,
+        definition.typeParamsDecl,
+        definition.superClass
+    );
+
+    return arkts.factory.updateClassDeclaration(node, updateClassDef);
+}
+
+export class StructTransformer extends AbstractVisitor {
+    visitor(beforeChildren: arkts.AstNode): arkts.AstNode {
+        const node = this.visitEachChild(beforeChildren);
+        if (arkts.isClassDeclaration(node) && isCustomComponentClass(node)) {
+            return tranformClassMembers(node);
+        }
+        return node;
+    }
+}
diff --git a/arkoala-arkts/libarkts/plugins/src/util.ts b/arkoala-arkts/libarkts/plugins/src/util.ts
deleted file mode 100644
index 3bbd8f63962a6728f6738e686a97037364034ba1..0000000000000000000000000000000000000000
--- a/arkoala-arkts/libarkts/plugins/src/util.ts
+++ /dev/null
@@ -1,163 +0,0 @@
-/*
- * Copyright (c) 2022-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 * as ts from "@koalaui/libarkts"
-import * as fs from 'fs'
-
-export enum FunctionKind {
-    REGULAR,
-    MEMO,
-    MEMO_INTRINSIC,
-}
-
-export type FunctionTable = Map<ts.SignatureDeclarationBase, FunctionKind>
-export type CallTable = Map<ts.CallExpression, FunctionKind>
-export type EntryTable = Set<ts.CallExpression>
-export type VariableTable = Map<ts.VariableLikeDeclaration, FunctionKind>
-
-export function isNamedDeclaration(node: ts.Node): node is ts.NamedDeclaration {
-    return ("name" in node )
-}
-
-export function asString(node: ts.Node | undefined): string {
-    if (node === undefined) {
-        return "undefined node"
-    }
-    if (ts.isIdentifier(node)) {
-        return node.text
-    }
-    if (isNamedDeclaration(node)) {
-        if (node.name === undefined) {
-            return `${ts.SyntaxKind[node.kind]}(undefined name)`
-        } else {
-            return `${ts.SyntaxKind[node.kind]}(${asString(node.name)})`
-        }
-    } else {
-        return `${ts.SyntaxKind[node.kind]}`
-    }
-}
-
-export function isFunctionOrMethod(node: ts.Node): node is ts.FunctionLikeDeclaration {
-    return ts.isFunctionDeclaration(node) ||
-           ts.isMethodDeclaration(node) ||
-           ts.isFunctionExpression(node) ||
-           ts.isArrowFunction(node)
-}
-
-export interface TransformerOptions {
-    // Emit transformed functions to the console.
-    trace?: boolean,
-    // Store the transformed functions to this directory.
-    keepTransformed?: string,
-    // Use human readable call site IDs without directory paths.
-    stableForTest?: boolean,
-    // Import context and id types from alternative source
-    contextImport?: string,
-    // Dump sources with resolved memo annotations to unmemoized directory
-    only_unmemoize?: boolean,
-    // Replace extension for output TS files
-    extension?: string,
-}
-
-function baseName(path: string): string {
-    return path.replace(/^.*\/(.*)$/, "$1")
-}
-
-export class Tracer {
-    constructor (
-        public options: TransformerOptions,
-        // TODO: implement ts.Printer
-        // public printer: arkts.Printer
-    ) {}
-
-    trace(msg: any) {
-        if (!this.options.trace) return
-        console.log(msg)
-    }
-
-    writeTextToFile(text: string, file: string) {
-        fs.writeFileSync(file, text, 'utf8')
-        this.trace("DUMP TO: " + file)
-    }
-
-    createDirs(dirs: string) {
-        fs.mkdirSync(dirs, { recursive: true });
-    }
-
-    dumpFileName(sourceFile: ts.SourceFile, transformed: ts.FunctionLikeDeclarationBase): string | undefined {
-        if (!this.options.keepTransformed) {
-            return undefined
-        }
-
-        const outDir = (this.options.keepTransformed[0] == "/") ?
-            this.options.keepTransformed :
-            `${__dirname}/${this.options.keepTransformed}`
-
-        this.createDirs(outDir)
-
-        const sourceBaseName = baseName(sourceFile.fileName)
-        if (!transformed.name) return
-        if (!ts.isIdentifier(transformed.name)) return
-        const fileName = `${transformed.name.text}_${sourceBaseName}`
-        return `${outDir}/${fileName}_dump`
-    }
-
-    keepTransformedFunction(transformed: ts.FunctionLikeDeclarationBase, sourceFile: ts.SourceFile) {
-        const fileName = this.dumpFileName(sourceFile, transformed)
-        if (!fileName) return
-
-        // TODO: implement ts.Printer
-        // const content = this.printer.printNode(arkts.EmitHint.Unspecified, transformed, sourceFile)
-        // this.writeTextToFile(content+"\n", fileName)
-    }
-}
-
-export enum RuntimeNames {
-    // COMPUTE = "compute",
-    // CONTEXT = "__memo_context",
-    // ID = "__memo_id",
-    // SCOPE = "__memo_scope",
-    // INTERNAL_PARAMETER_STATE = "param",
-    // INTERNAL_VALUE = "cached",
-    // INTERNAL_VALUE_NEW = "recache",
-    // INTERNAL_SCOPE = "scope",
-    // INTERNAL_VALUE_OK = "unchanged",
-    // CONTENT = "content",
-    // VALUE = "value",
-    // __CONTEXT = "__context",
-    // __ID = "__id",
-    // __KEY = "__key",
-    // __STATE = "__state",
-    // CONTEXT_TYPE = "__memo_context_type",
-    // ID_TYPE = "__memo_id_type",
-    // TRANSFORMED_TYPE = "__memo_transformed",
-    // SYNTHETIC_RETURN_MARK = "__synthetic_return_value",
-    // CONTEXT_TYPE_DEFAULT_IMPORT = "@koalaui/runtime",
-    ANNOTATION = "_memo",
-    ANNOTATION_INTRINSIC = "_memo:intrinsic",
-    ANNOTATION_ENTRY = "_memo:entry",
-    ANNOTATION_SKIP = "_skip:memo", // skip binding to parameter changes
-    ANNOTATION_STABLE = "_memo:stable", // assume this should not be tracked
-}
-
-export function findFunctionDeclaration(node: ts.Node): ts.FunctionDeclaration | undefined {
-    while (node.kind !== ts.SyntaxKind.SourceFile) {
-        if (ts.isFunctionDeclaration(node)) {
-            return node
-        }
-        node = node.parent
-    }
-    return undefined
-}
diff --git a/arkoala-arkts/libarkts/plugins/src/utils.ts b/arkoala-arkts/libarkts/plugins/src/utils.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e3746e9253bb323b196ee4da822b8a723e8bedd3
--- /dev/null
+++ b/arkoala-arkts/libarkts/plugins/src/utils.ts
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) 2022-2025 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 { UniqueId } from "@koalaui/common"
+import * as arkts from "@koalaui/libarkts"
+
+export enum RuntimeNames {
+    __CONTEXT = "__context",
+    __ID = "__id",
+    ANNOTATION = "memo",
+    CONTEXT = "__memo_context",
+    CONTEXT_TYPE = "__memo_context_type",
+    CONTEXT_TYPE_DEFAULT_IMPORT = "@koalaui/runtime",
+    ID = "__memo_id",
+    ID_TYPE = "__memo_id_type",
+    INTERNAL_SCOPE = "scope",
+    INTERNAL_VALUE = "cached",
+    INTERNAL_VALUE_NEW = "recache",
+    INTERNAL_VALUE_OK = "unchanged",
+    SCOPE = "__memo_scope",
+}
+
+export function createContextTypeImportSpecifier(): arkts.ImportSpecifier {
+    return arkts.factory.createImportSpecifier(
+        arkts.factory.createIdentifier(RuntimeNames.CONTEXT_TYPE),
+        arkts.factory.createIdentifier(RuntimeNames.CONTEXT_TYPE),
+    )
+}
+
+export function createIdTypeImportSpecifier(): arkts.ImportSpecifier {
+    return arkts.factory.createImportSpecifier(
+        arkts.factory.createIdentifier(RuntimeNames.ID_TYPE),
+        arkts.factory.createIdentifier(RuntimeNames.ID_TYPE),
+    )
+}
+
+export function createContextParameter(): arkts.ETSParameterExpression {
+    return arkts.factory.createParameterDeclaration(
+        arkts.factory.createIdentifier(RuntimeNames.CONTEXT,
+            arkts.factory.createIdentifier(RuntimeNames.CONTEXT_TYPE)
+        ),
+        undefined
+    )
+}
+
+export function createIdParameter(): arkts.ETSParameterExpression {
+    return arkts.factory.createParameterDeclaration(
+        arkts.factory.createIdentifier(RuntimeNames.ID,
+            arkts.factory.createIdentifier(RuntimeNames.ID_TYPE)
+        ),
+        undefined
+    )
+}
+
+export function createContextArgument(): arkts.AstNode {
+    return arkts.factory.createIdentifier(RuntimeNames.CONTEXT)
+}
+
+export function createIdArgument(hash: arkts.NumberLiteral | arkts.StringLiteral): arkts.AstNode {
+    return arkts.factory.createBinaryExpression(
+        arkts.factory.createIdentifier(RuntimeNames.ID),
+        arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_PLUS,
+        hash
+    )
+}
+
+function baseName(path: string): string {
+    return path.replace(/^.*\/(.*)$/, "$1")
+}
+
+export class PositionalIdTracker {
+    // Global for the whole program.
+    static callCount: number = 0
+
+    // Set `stable` to true if you want to have more predictable values.
+    // For example for tests.
+    // Don't use it in production!
+    constructor(public filename: string, public stableForTests: boolean = false) {
+        if (stableForTests) PositionalIdTracker.callCount = 0
+    }
+
+    sha1Id(callName: string, fileName: string): string {
+        const uniqId = new UniqueId()
+        uniqId.addString("memo call uniqid")
+        uniqId.addString(fileName)
+        uniqId.addString(callName)
+        uniqId.addI32(PositionalIdTracker.callCount++)
+        return uniqId.compute().substring(0, 7)
+    }
+
+    stringId(callName: string, fileName: string): string {
+        return `${PositionalIdTracker.callCount++}_${callName}_id_DIRNAME/${fileName}`
+    }
+
+    id(callName: string): arkts.NumberLiteral | arkts.StringLiteral {
+
+        const fileName = this.stableForTests ?
+            baseName(this.filename) :
+            this.filename
+
+        const positionId = (this.stableForTests) ?
+            this.stringId(callName, fileName) :
+            this.sha1Id(callName, fileName)
+
+
+        return this.stableForTests
+            ? arkts.factory.createStringLiteral(positionId)
+            : arkts.factory.createNumericLiteral(parseInt(positionId, 16))
+    }
+}
diff --git a/arkoala-arkts/libarkts/plugins/tsconfig.json b/arkoala-arkts/libarkts/plugins/tsconfig.json
index d0ce6f2228dd65d7edd13be46f938c0f80e98558..8f86fc2ea37fed27d3bc6294a7917489ee5d5fdb 100644
--- a/arkoala-arkts/libarkts/plugins/tsconfig.json
+++ b/arkoala-arkts/libarkts/plugins/tsconfig.json
@@ -14,5 +14,13 @@
         "./src/print-visitor.ts",
         "./src/builder-lambda-transformer.ts",
         "./src/component-transformer.ts",
+        "./src/struct-transformer.ts",
+        "./src/arkts-utils.ts",
+        "./src/index.ts",
+        "./src/utils.ts",
+        "./src/function-transformer.ts",
+        "./src/import-transformer.ts",
+        "./src/memo-transformer.ts",
+        "./src/only-test-transformer.ts",
     ]
 }
diff --git a/arkoala-arkts/libarkts/src/Es2pandaNativeModule.ts b/arkoala-arkts/libarkts/src/Es2pandaNativeModule.ts
index e62809f69870d79fb9ddeab09c92f0c51464216b..ab11cd9de419983c3c177cc5c9cbda1dde17fa22 100644
--- a/arkoala-arkts/libarkts/src/Es2pandaNativeModule.ts
+++ b/arkoala-arkts/libarkts/src/Es2pandaNativeModule.ts
@@ -53,6 +53,9 @@ export class Es2pandaNativeModule {
     _AnnotationAllowedAnnotations(context: KPtr, node: KPtr, returnLen: KPtr): KPtr {
         throw new Error("Not implemented")
     }
+    _AnnotationAllowedAnnotationsConst(context: KPtr, node: KPtr, returnLen: KPtr): KPtr {
+        throw new Error("Not implemented")
+    }
     _AstNodeRebind(context: KPtr, node: KPtr): void {
         throw new Error("Not implemented")
     }
@@ -164,6 +167,9 @@ export class Es2pandaNativeModule {
     _ScriptFunctionBody(context: KPtr, node: KPtr): KPtr {
         throw new Error("Not implemented")
     }
+    _ScriptFunctionAnnotations(context: KPtr, node: KPtr, returnLen: KPtr): KPtr {
+        throw new Error("Not implemented")
+    }
     _ScriptFunctionSetIdent(context: KPtr, ast: KPtr, id: KPtr): KPtr {
         throw new Error("Not implemented")
     }
@@ -176,6 +182,9 @@ export class Es2pandaNativeModule {
     _ScriptFunctionSetScope(context: KPtr, ast: KPtr, scope: KPtr): KPtr {
         throw new Error("Not implemented")
     }
+    _ScriptFunctionSetAnnotations(context: KPtr, ast: KPtr, annotations: KPtrArray, annotationsLen: KInt): KPtr {
+        throw new Error("Not implemented")
+    }
     _ScriptFunctionDeclareConst(context: KPtr, node: KPtr): KBoolean {
         throw new Error("Not implemented")
     }
@@ -191,6 +200,12 @@ export class Es2pandaNativeModule {
     _ScriptFunctionAddFlag(context: KPtr, node: KPtr, flags: KInt): void {
         throw new Error("Not implemented")
     }
+    _ClassPropertyAnnotations(context: KPtr, node: KPtr, returnLen: KPtr): KPtr {
+        throw new Error("Not implemented")
+    }
+    _ClassPropertySetAnnotations(context: KPtr, ast: KPtr, annotations: KPtrArray, annotationsLen: KInt): KPtr {
+        throw new Error("Not implemented")
+    }
     _UpdateBlockStatement(context: KPtr, original: KPtr, statementList: KPtrArray, statementListLen: KInt): KPtr {
         throw new Error("Not implemented")
     }
@@ -392,6 +407,12 @@ export class Es2pandaNativeModule {
     _ETSParameterExpressionIdent(context: KPtr, node: KPtr): KPtr {
         throw new Error("Not implemented")
     }
+    _ETSParameterExpressionAnnotations(context: KPtr, node: KPtr, returnLen: KPtr): KPtr {
+        throw new Error("Not implemented")
+    }
+    _ETSParameterExpressionSetAnnotations(context: KPtr, ast: KPtr, annotations: KPtrArray, annotationsLen: KInt): KPtr {
+        throw new Error("Not implemented")
+    }
     _CreateTSTypeParameterDeclaration(context: KPtr, params: KPtrArray, paramsLen: KInt, requiredParams: KInt): KPtr {
         throw new Error("Not implemented")
     }
@@ -551,6 +572,29 @@ export class Es2pandaNativeModule {
     _DeclarationFromIdentifier(context: KPtr, identifier: KPtr): KPtr {
         throw new Error("Not implemented")
     }
+    _IsTSInterfaceDeclaration(ast: KNativePointer): KBoolean {
+        throw new Error("Not implemented")
+    }
+
+    _IsAnnotationDeclaration(ast: KNativePointer): KBoolean {
+        throw new Error("Not implemented")
+    }
+
+    _IsAnnotationUsage(ast: KNativePointer): KBoolean {
+        throw new Error("Not implemented")
+    }
+
+    _IsClassProperty(ast: KNativePointer): KBoolean {
+        throw new Error("Not implemented")
+    }
+
+    _CreateAnnotationUsageIr(context: KPtr, ast: KPtr): KPtr {
+        throw new Error("Not implemented")
+    }
+
+    _IsETSImportDeclaration(ast: KNativePointer): KBoolean {
+        throw new Error("Not implemented")
+    }
 }
 
 export function initEs2panda(): Es2pandaNativeModule {
diff --git a/arkoala-arkts/libarkts/src/arkts-api/factory/nodeFactory.ts b/arkoala-arkts/libarkts/src/arkts-api/factory/nodeFactory.ts
index ff36ada6fe71586ed48aadfffa6919ab11c5a85b..778cb68cd88abd0fc89f5238275434e26e481e93 100644
--- a/arkoala-arkts/libarkts/src/arkts-api/factory/nodeFactory.ts
+++ b/arkoala-arkts/libarkts/src/arkts-api/factory/nodeFactory.ts
@@ -15,12 +15,14 @@
 
 import { updateNodeByNode } from "../utilities/private"
 import {
+    AnnotationUsageIr,
     ArrowFunctionExpression,
     BinaryExpression,
     BlockStatement,
     CallExpression,
     ClassDeclaration,
     ClassDefinition,
+    ClassProperty,
     ETSFunctionType,
     EtsImportDeclaration,
     ETSParameterExpression,
@@ -46,6 +48,7 @@ import {
     TSTypeParameter,
     TSTypeParameterDeclaration,
     TSTypeParameterInstantiation,
+    UndefinedLiteral,
     VariableDeclaration,
     VariableDeclarator
 } from "../types"
@@ -238,6 +241,12 @@ export const factory = {
     get updateClassDefinition() {
         return compose(ClassDefinition.create)
     },
+    get createClassProperty() {
+        return ClassProperty.create
+    },
+    get updateClassProperty() {
+        return compose(ClassProperty.create)
+    },
     get createFunctionType() {
         return ETSFunctionType.create
     },
@@ -274,4 +283,16 @@ export const factory = {
     get updateInterfaceDeclaration() {
         return compose(TSInterfaceDeclaration.create)
     },
+    get createUndefinedLiteral() {
+        return UndefinedLiteral.create
+    },
+    get updateUndefinedLiteral() {
+        return compose(UndefinedLiteral.create)
+    },
+    get createAnnotationUsageIr() {
+        return AnnotationUsageIr.create
+    },
+    get updateAnnotationUsageIr() {
+        return compose(UndefinedLiteral.create)
+    },
 }
diff --git a/arkoala-arkts/libarkts/src/arkts-api/factory/nodeTests.ts b/arkoala-arkts/libarkts/src/arkts-api/factory/nodeTests.ts
index 07750fe2ffb1e9e3c7d35614b9f4485866415eaf..fc3d83db460efaf60cf61baa8f9cf3d96263ae80 100644
--- a/arkoala-arkts/libarkts/src/arkts-api/factory/nodeTests.ts
+++ b/arkoala-arkts/libarkts/src/arkts-api/factory/nodeTests.ts
@@ -1,4 +1,7 @@
+import { global } from "../static/global"
 import {
+    AnnotationDeclaration,
+    AnnotationUsageIr,
     ArrowFunctionExpression,
     BlockStatement,
     CallExpression,
@@ -14,11 +17,34 @@ import {
     ScriptFunction,
     StringLiteral,
     StructDeclaration,
+    TSInterfaceDeclaration,
     VariableDeclaration,
+    ClassProperty,
+    EtsImportDeclaration
 } from "../types"
 import { MemberExpression } from "../to-be-generated/MemberExpression"
 import { AstNode } from "../peers/AstNode"
 
+export function isEtsImportDeclaration(node: AstNode): node is EtsImportDeclaration {
+    return global.es2panda._IsETSImportDeclaration(node.peer);
+}
+
+export function isClassProperty(node: AstNode): node is ClassProperty {
+    return global.es2panda._IsClassProperty(node.peer);
+}
+
+export function isAnnotationUsage(node: AstNode): node is AnnotationUsageIr {
+    return global.es2panda._IsAnnotationUsage(node.peer);
+}
+
+export function isAnnotationDeclaration(node: AstNode): node is AnnotationDeclaration {
+    return global.es2panda._IsAnnotationDeclaration(node.peer);
+}
+
+export function isTSInterfaceDeclaration(node: AstNode): node is TSInterfaceDeclaration {
+    return global.es2panda._IsTSInterfaceDeclaration(node.peer);
+}
+
 export function isIdentifier(node: AstNode): node is Identifier {
     return node instanceof Identifier
 }
diff --git a/arkoala-arkts/libarkts/src/arkts-api/peers/Context.ts b/arkoala-arkts/libarkts/src/arkts-api/peers/Context.ts
index 07fede2a8f024ee5ecad4c826e688476c4dc2ba2..e97112dfef3dd170800d93e3b5fa13debeeda04b 100644
--- a/arkoala-arkts/libarkts/src/arkts-api/peers/Context.ts
+++ b/arkoala-arkts/libarkts/src/arkts-api/peers/Context.ts
@@ -15,9 +15,10 @@
 
 import { ArktsObject } from "./ArktsObject"
 import { global } from "../static/global"
-import { throwError } from "../../utils"
+import { throwError, filterSource } from "../../utils"
 import { passString } from "../utilities/private"
 import { KNativePointer } from "@koalaui/interop"
+import { AstNode } from "./AstNode"
 
 export class Context extends ArktsObject {
     constructor(peer: KNativePointer) {
@@ -41,4 +42,14 @@ export class Context extends ArktsObject {
             )
         )
     }
+
+    static destroyAndRecreate(
+        ast: AstNode
+    ): Context {
+        const source = filterSource(ast.dumpSrc())
+        global.es2panda._DestroyContext(global.context)
+        global.context = Context.createFromString(source).peer
+
+        return new Context(global.context);
+    }
 }
\ No newline at end of file
diff --git a/arkoala-arkts/libarkts/src/arkts-api/static/global.ts b/arkoala-arkts/libarkts/src/arkts-api/static/global.ts
index 97d82523d6fe7a32dc6944f6e953452eedfd803f..bdbd0582e7765628b1df24916c063f0fc9c39909 100644
--- a/arkoala-arkts/libarkts/src/arkts-api/static/global.ts
+++ b/arkoala-arkts/libarkts/src/arkts-api/static/global.ts
@@ -65,4 +65,8 @@ export class global {
         if (this._interop === undefined) this._interop = initInterop()
         return this._interop
     }
+
+    public static resetConfig() {
+        global._config = undefined;
+    }
 }
diff --git a/arkoala-arkts/libarkts/src/arkts-api/types.ts b/arkoala-arkts/libarkts/src/arkts-api/types.ts
index 10b6b5197ea8d416e498ade67fe08e32b860a421..2aa36a747e80936f7ada93594a4b604fb6f504fc 100644
--- a/arkoala-arkts/libarkts/src/arkts-api/types.ts
+++ b/arkoala-arkts/libarkts/src/arkts-api/types.ts
@@ -19,6 +19,7 @@ import { KBoolean, KInt, KNativePointer as KPtr, nullptr } from "@koalaui/intero
 import {
     Es2pandaClassDefinitionModifiers,
     Es2pandaContextState,
+    Es2pandaExpressionParseFlags,
     Es2pandaIdentifierFlags,
     Es2pandaImportKinds,
     Es2pandaMethodDefinitionKind,
@@ -157,6 +158,7 @@ export class CallExpression extends AstNode {
         super(peer)
         this.expression = unpackNonNullableNode(
             global.generatedEs2panda._CallExpressionCallee(global.context, this.peer))
+        this.typeParamsDecl = unpackNode(global.generatedEs2panda._CallExpressionTypeParams(global.context, this.peer))
         this.arguments = unpackNodeArray(
             global.generatedEs2panda._CallExpressionArguments(global.context, this.peer))
         this.trailingBlock = unpackNode(
@@ -165,7 +167,7 @@ export class CallExpression extends AstNode {
 
     static create(
         expression: AstNode,
-        typeParamsDecl: TSTypeParameterDeclaration | undefined,
+        typeParamsDecl: TSTypeParameterInstantiation | TSTypeParameterDeclaration | undefined,
         args: readonly AstNode[] | undefined,
         trailingBlock: AstNode | undefined = undefined
     ): CallExpression {
@@ -187,6 +189,7 @@ export class CallExpression extends AstNode {
         return call
     }
 
+    readonly typeParamsDecl: TSTypeParameterInstantiation | TSTypeParameterDeclaration | undefined;
     readonly expression: AstNode // Expression
     readonly arguments: readonly AstNode[]
     readonly trailingBlock: AstNode|undefined // BlockStatement
@@ -298,6 +301,7 @@ export class ETSTypeReferencePart extends AstNode {
     constructor(peer: KPtr) {
         assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE_PART)
         super(peer)
+        this.typeName = unpackNonNullableNode(global.generatedEs2panda._ETSTypeReferencePartName(global.context, this.peer));
     }
 
     // TODO: support type params and prev
@@ -317,7 +321,7 @@ export class ETSTypeReferencePart extends AstNode {
         )
     }
 
-    // readonly typeName: Identifier
+    readonly typeName: Identifier
 }
 
 export class TSUnionType extends AstNode {
@@ -396,9 +400,18 @@ export class Identifier extends AstNode {
 
     static create(
         name: string,
-        typeAnnotation?: AstNode
+        typeAnnotation?: AstNode,
+        isAnnotation?: boolean
     ): Identifier {
-        if (typeAnnotation === undefined) {
+        if (isAnnotation) {
+            return new Identifier(
+                global.es2panda._ETSParserCreateExpression(
+                    global.context, 
+                    passString(name),
+                    Es2pandaExpressionParseFlags.EXPRESSION_PARSE_FLAGS_ACCEPT_COMMA
+                )
+            )
+        } else if (typeAnnotation === undefined) {
             return new Identifier(
                 global.es2panda._CreateIdentifier1(global.context, passString(name))
             )
@@ -409,6 +422,16 @@ export class Identifier extends AstNode {
         }
     }
 
+    setOptional(optional: boolean): Identifier {
+        global.generatedEs2panda._IdentifierSetOptional(global.context, this.peer, optional)
+        return this
+    }
+
+    setAnnotationUsage(): Identifier {
+        global.generatedEs2panda._IdentifierSetAnnotationUsage(global.context, this.peer);
+        return this;
+    }
+
     protected override dumpMessage(): string {
         return ` <name: ${this.name}> <identifierFlags: ${this.identifierFlags}>`
     }
@@ -554,6 +577,12 @@ export class ScriptFunction extends AstNode {
         return new ScriptFunction(peer)
     }
 
+    setIdent(id: Identifier): ScriptFunction {
+        assertValidPeer(id.peer, Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER);
+        global.generatedEs2panda._ScriptFunctionSetIdent(global.context, this.peer, id.peer);
+        return this;
+    }
+
     protected override dumpMessage(): string {
         const scriptFunctionFlags = global.generatedEs2panda._ScriptFunctionFlagsConst(global.context, this.peer)
         return ` <scriptFunctionFlags: ${scriptFunctionFlags} (${scriptFunctionFlags.toString(2).split("").reverse().join("")})>`
@@ -596,6 +625,24 @@ export class ScriptFunction extends AstNode {
     // readonly signature: FunctionSignature
     readonly scriptFunctionFlags: KInt
     readonly ident?: Identifier
+
+    get annotations(): AnnotationUsageIr[] {
+        return unpackNodeArray(global.es2panda._ScriptFunctionAnnotations(
+            global.context, 
+            this.peer, 
+            nullptr
+        )) as AnnotationUsageIr[];
+    }
+
+    set annotations(newAnnotations: AnnotationUsageIr[]) {
+        const _peer = global.es2panda._ScriptFunctionSetAnnotations(
+            global.context, 
+            this.peer, 
+            passNodeArray(newAnnotations),
+            newAnnotations.length
+        );
+        // global.es2panda._AstNodeUpdateAll(global.context, _peer)
+    }
 }
 
 export class ArrowFunctionExpression extends AstNode {
@@ -707,6 +754,7 @@ export class ETSParameterExpression extends AstNode {
     constructor(peer: KPtr) {
         assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION)
         super(peer)
+        // this.annotations = unpackNodeArray(global.es2panda._ETSParameterExpressionAnnotations(global.context, this.peer, nullptr)) as AnnotationUsageIr[];
     }
 
     static create(
@@ -721,6 +769,23 @@ export class ETSParameterExpression extends AstNode {
             )
         )
     }
+
+    get annotations(): AnnotationUsageIr[] {
+        return unpackNodeArray(global.es2panda._ETSParameterExpressionAnnotations(
+            global.context, 
+            this.peer, 
+            nullptr
+        )) as AnnotationUsageIr[];
+    }
+
+    set annotations(newAnnotations: AnnotationUsageIr[]) {
+        global.es2panda._ETSParameterExpressionSetAnnotations(
+            global.context, 
+            this.peer, 
+            passNodeArray(newAnnotations),
+            newAnnotations.length
+        );
+    }
 }
 
 export class TSTypeParameterDeclaration extends AstNode {
@@ -933,12 +998,21 @@ export class ClassStaticBlock extends AstNode {
 }
 
 export class MethodDefinition extends AstNode {
-    constructor(peer: KPtr) {
+    constructor(peer: KPtr, key?: KPtr) {
         assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION)
         super(peer)
+        this.kind = global.generatedEs2panda._MethodDefinitionKindConst(global.context, this.peer);
         this.scriptFunction = unpackNonNullableNode(global.generatedEs2panda._MethodDefinitionFunction(global.context, this.peer))
+        assertValidPeer(this.scriptFunction.peer, Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION);
+
+        // Somehow the scriptFunction cannot attach method's key to its ident after checker
+        if (key) {
+            assertValidPeer(key, Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER);
+            const _name = unpackNonNullableNode(key);
+            this.scriptFunction = this.scriptFunction.setIdent(_name as Identifier);
+        }
+
         this.name = unpackNonNullableNode(global.generatedEs2panda._ScriptFunctionId(global.context, this.scriptFunction.peer))
-        this.kind = global.generatedEs2panda._MethodDefinitionKindConst(global.context, this.peer)
     }
 
     static create(
@@ -956,13 +1030,19 @@ export class MethodDefinition extends AstNode {
                 passNode(value),
                 modifiers,
                 isComputed
-            )
+            ),
+            key.peer
         )
     }
 
+    // TODO: does not work
+    isConstructor(): boolean {
+        return global.generatedEs2panda._MethodDefinitionIsConstructorConst(global.context, this.peer);
+    }
+
+    readonly kind: Es2pandaMethodDefinitionKind;
     readonly scriptFunction: ScriptFunction
     readonly name: Identifier
-    readonly kind: Es2pandaMethodDefinitionKind
 }
 
 export class ClassElement extends AstNode {
@@ -980,6 +1060,8 @@ export class ClassProperty extends ClassElement {
     constructor(peer: KPtr) {
         assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY)
         super(peer)
+        this.typeAnnotation = unpackNonNullableNode(global.generatedEs2panda._ClassPropertyTypeAnnotationConst(global.context, this.peer));
+        // this.annotations = unpackNodeArray(global.es2panda._ClassPropertyAnnotations(global.context, this.peer, nullptr)) as AnnotationUsageIr[];
     }
 
     static create(
@@ -1000,6 +1082,25 @@ export class ClassProperty extends ClassElement {
             )
         )
     }
+
+    get annotations(): AnnotationUsageIr[] {
+        return unpackNodeArray(global.es2panda._ClassPropertyAnnotations(
+            global.context, 
+            this.peer, 
+            nullptr
+        )) as AnnotationUsageIr[];
+    }
+
+    set annotations(newAnnotations: AnnotationUsageIr[]) {
+        global.es2panda._ClassPropertySetAnnotations(
+            global.context, 
+            this.peer, 
+            passNodeArray(newAnnotations),
+            newAnnotations.length
+        );
+    }
+
+    readonly typeAnnotation: ETSTypeReference;
 }
 
 export class VariableDeclaration extends AstNode {
@@ -1067,6 +1168,7 @@ export class SuperExpression extends AstNode {
     constructor(peer: KPtr) {
         assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION)
         super(peer)
+        this.id = unpackNonNullableNode(global.generatedEs2panda._TSInterfaceDeclarationId(global.context, this.peer));
     }
 
     static create(
@@ -1077,6 +1179,8 @@ export class SuperExpression extends AstNode {
             )
         )
     }
+
+    readonly id?: Identifier;
 }
 
 export class ImportSource extends ArktsObject {
@@ -1162,11 +1266,19 @@ export class AnnotationUsageIr extends AstNode {
         assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE)
         super(peer)
         this.expr = unpackNonNullableNode(global.generatedEs2panda._AnnotationUsageIrExpr(global.context, this.peer))
-        this.properties = unpackNodeArray(global.generatedEs2panda._AnnotationUsageIrPropertiesConst(global.context, this.peer))
+        this.properties = unpackNodeArray(global.generatedEs2panda._AnnotationUsageIrProperties(global.context, this.peer))
     }
 
-    // TODO:
-    // static create
+    static create(
+        annoIdent: AstNode
+    ): AnnotationUsageIr {
+        return new AnnotationUsageIr(
+            global.es2panda._CreateAnnotationUsageIr(
+                global.context,
+                passNode(annoIdent)
+            )
+        );
+    }
 
     readonly expr: AstNode
     readonly properties: readonly ClassProperty[]
@@ -1225,4 +1337,28 @@ export class UndefinedLiteral extends AstNode {
         assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_UNDEFINED_LITERAL)
         super(peer)
     }
+
+    static create(): UndefinedLiteral {
+        return new UndefinedLiteral(
+            global.generatedEs2panda._CreateUndefinedLiteral(global.context)
+        )
+    }
+}
+
+export class AnnotationDeclaration extends AstNode {
+    constructor(peer: KPtr) {
+        assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_DECLARATION);
+        super(peer)
+    }
+
+    static create(
+        expr: AstNode
+    ): AnnotationDeclaration {
+        return new AnnotationDeclaration (
+            global.generatedEs2panda._CreateAnnotationDeclaration(
+                global.context,
+                passNode(expr)
+            )
+        )
+    }
 }
diff --git a/arkoala-arkts/libarkts/src/arkts-api/utilities/public.ts b/arkoala-arkts/libarkts/src/arkts-api/utilities/public.ts
index dbea933f3c14c53834281e4863a39e766a3d4279..4d9142e009e04255fbf717e8ea4d63e3aa67db30 100644
--- a/arkoala-arkts/libarkts/src/arkts-api/utilities/public.ts
+++ b/arkoala-arkts/libarkts/src/arkts-api/utilities/public.ts
@@ -16,12 +16,11 @@
 import { global } from "../static/global"
 import { throwError } from "../../utils"
 import { KNativePointer, nullptr, withStringResult } from "@koalaui/interop"
-import { AnnotationUsageIr, MethodDefinition } from "../types"
 import { passNode, unpackNodeArray, unpackNonNullableNode } from "./private"
 import { isClassDefinition, isFunctionDeclaration, isScriptFunction } from "../factory/nodeTests"
 import { Es2pandaContextState } from "../../generated/Es2pandaEnums"
 import { AstNode } from "../peers/AstNode"
-import { Identifier } from "../types"
+import { AnnotationUsageIr } from "../types"
 
 export function proceedToState(state: Es2pandaContextState): void {
     if (state <= global.es2panda._ContextState(global.context)) {
@@ -83,3 +82,12 @@ export function getOriginalNode(node: AstNode): AstNode {
 export function getFileName(): string {
     return global.filePath
 }
+
+export function destroyConfig(config: KNativePointer): void {
+    global.es2panda._DestroyConfig(config);
+    global.resetConfig();
+}
+
+export function setAllParents(ast: AstNode): void {
+    global.es2panda._AstNodeUpdateAll(global.context, ast.peer)
+}
diff --git a/arkoala-arkts/libarkts/src/arkts-api/visitor.ts b/arkoala-arkts/libarkts/src/arkts-api/visitor.ts
index 0e0121e9e9e57bf433ee702f2af2f7a79c13f89c..54df4f17a577c78b35005cb4499ef5420490d3fc 100644
--- a/arkoala-arkts/libarkts/src/arkts-api/visitor.ts
+++ b/arkoala-arkts/libarkts/src/arkts-api/visitor.ts
@@ -35,9 +35,57 @@ import {
 import { nullptr } from "@koalaui/interop"
 import { AstNode } from "./peers/AstNode"
 import { MemberExpression } from "../reexport-for-generated"
+import { isClassDefinition, isMethodDefinition, isScriptFunction } from "./factory/nodeTests"
 
 type Visitor = (node: AstNode) => AstNode
 
+export interface DoubleNode {
+    originNode: AstNode;
+    translatedNode: AstNode;
+}
+
+export class StructInfo {
+    stateVariables: Set<DoubleNode> = new Set();
+}
+
+export class GlobalInfo {
+    private _structCollection: Set<string>;
+    private static instance: GlobalInfo;
+    private _structMap: Map<string, StructInfo>;
+
+    private constructor() {
+        this._structCollection = new Set();
+        this._structMap = new Map();
+    }
+
+    public static getInfoInstance(): GlobalInfo {
+        if (!this.instance) {
+            this.instance = new GlobalInfo();
+        }
+        return this.instance;
+    }
+
+    public add(str: string): void {
+        this._structCollection.add(str);
+    }
+
+    public getStructCollection(): Set<string> {
+        return this._structCollection;
+    }
+
+    public getStructInfo(structName: string): StructInfo {
+        const structInfo = this._structMap.get(structName);
+        if (!structInfo) {
+            return new StructInfo();
+        }
+        return structInfo;
+    }
+
+    public setStructInfo(structName: string, info: StructInfo): void {
+        this._structMap.set(structName, info);
+    }
+}
+
 // TODO: rethink (remove as)
 function nodeVisitor<T extends AstNode | undefined>(node: T, visitor: Visitor): T {
     if (node === undefined) {
@@ -104,7 +152,7 @@ export function visitEachChild(
             nodeVisitor(node.definition, visitor)
         )
     }
-    if (node instanceof ClassDefinition) {
+    if (isClassDefinition(node)) {
         // TODO: fix
         return factory.updateClassDefinition(
             node,
@@ -119,9 +167,9 @@ export function visitEachChild(
             nodeVisitor(node.superClass, visitor),
         )
     }
-    if (node instanceof MethodDefinition) {
+    if (isMethodDefinition(node)) {
         // TODO: fix
-        return factory.updateMethodDefinition(
+        const _node = factory.updateMethodDefinition(
             node,
             node.kind,
             node.name,
@@ -145,18 +193,18 @@ export function visitEachChild(
             node.modifiers,
             false
         )
+
+        // TODO: something need to fix with annotation assignments
+        try {
+            _node.scriptFunction.annotations = node.scriptFunction.annotations;
+        } catch (e) {
+
+        }
+
+        return _node;
     }
-    if (node instanceof ScriptFunction) {
-        return factory.updateScriptFunction(
-            node,
-            nodeVisitor(node.body, visitor),
-            nullptr,
-            node.scriptFunctionFlags,
-            Es2pandaModifierFlags.MODIFIER_FLAGS_NONE,
-            false,
-            nodeVisitor(node.ident, visitor),
-            nodesVisitor(node.parameters, visitor)
-        )
+    if (isScriptFunction(node)) {
+        return node;
     }
     if (node instanceof EtsImportDeclaration) {
         return factory.updateImportDeclaration(
diff --git a/arkoala-arkts/libarkts/src/es2panda.ts b/arkoala-arkts/libarkts/src/es2panda.ts
index 46ba9309be52164319da72f3f2df3933d8e0b2da..19dfe55c513bb2a92f3735aad2b2ba55a0700a0d 100644
--- a/arkoala-arkts/libarkts/src/es2panda.ts
+++ b/arkoala-arkts/libarkts/src/es2panda.ts
@@ -194,3 +194,6 @@ export function main() {
 }
 
 main()
+
+// import * as arkts from "./arkts-api"
+// export { arkts, global as arktsGlobal };
\ No newline at end of file
diff --git a/arkoala-arkts/trivial/user/arktsconfig-pure-sts.json b/arkoala-arkts/trivial/user/arktsconfig-pure-sts.json
index 551fb7ed8776980bbc9bca07f17a1f373fae2bea..32be4a65b56362b5b86b63886d5357efadfd6de7 100644
--- a/arkoala-arkts/trivial/user/arktsconfig-pure-sts.json
+++ b/arkoala-arkts/trivial/user/arktsconfig-pure-sts.json
@@ -4,7 +4,17 @@
         "outDir": "build/sts/abc",
         "baseUrl": ".",
         "paths": {
-            "@ohos.arkui": ["../../arkui/src/sts"]
+            "@ohos.arkui": ["../../arkui/src/sts/arkui.sts"],
+            "@ohos.arkui.after.check": ["../../arkui/src/sts/arkui.after.check.sts"],
+            "@koalaui/runtime": [
+                "../../memo-plugin/runtime-api"
+            ],
+            "@koalaui/compat": [
+                "../../../incremental/compat/src/arkts"
+            ],
+            "@koalaui/common": [
+                "../../../incremental/common/src"
+            ]
         },
        "plugins": [
             {
@@ -14,7 +24,7 @@
             {
                 "transform": "@koalaui/libarkts/plugins/parsed-stage-plugin",
                 "stage": "parsed",
-                "arkui": "../../../../arkui/src/sts"
+                "arkui": "@ohos.arkui"
             },
             {
                 "transform": "@koalaui/libarkts/plugins/checked-stage-plugin",
diff --git a/arkoala-arkts/trivial/user/src/sts/hello.sts b/arkoala-arkts/trivial/user/src/sts/hello.sts
index 41c42c50e77df8a917c5b8494489635b438fcf3a..1923eb273dc52ae930be03dfe16adb20d8893518 100644
--- a/arkoala-arkts/trivial/user/src/sts/hello.sts
+++ b/arkoala-arkts/trivial/user/src/sts/hello.sts
@@ -1,7 +1,7 @@
 import { Text } from "@ohos.arkui"
 import { Column, ColumnOptions } from "@ohos.arkui"
 import { Button } from "@ohos.arkui"
-import { Component, State, Entry } from "@ohos.arkui"
+import { Component, State, Entry, memo } from "@ohos.arkui"
 import { Color } from "@ohos.arkui"
 
 @Entry