@idlizer/arktscgen 2.1.5 → 2.1.9-arktscgen-4

package/lib/index.js

@@ -136,7 +136,7 @@ function error(
         : 1;
 
   const precedingLastLine = lastLine(
-    tokensToText(sliceTokens(-5), { precedes: true }),
+    tokensToText(sliceTokens(-maxTokens), { precedes: true }),
   );
 
   const subsequentTokens = sliceTokens(maxTokens);
@@ -1605,19 +1605,52 @@ class CallbackFunction extends Base {
 /**
  * @param {import("../tokeniser.js").Tokeniser} tokeniser
  */
-function inheritance(tokeniser) {
+function inheritanceItem(tokeniser) {
+  const extAttrs = ExtendedAttributes.parse(tokeniser);
+  const inheritance = tokeniser.consumeKind("identifier");
+  if (!inheritance) {
+    return undefined;
+  }
+  return {
+    extAttrs,
+    inheritance,
+    tokens: {},
+  };
+}
+
+/**
+ * @param {import("../tokeniser.js").Tokeniser} tokeniser
+ * @param {boolean} multipleInheritance
+ */
+function inheritance(tokeniser, multipleInheritance) {
   const colon = tokeniser.consume(":");
   if (!colon) {
     return {};
   }
-  const extAttrs = ExtendedAttributes.parse(tokeniser);
-  const inheritance =
-    tokeniser.consumeKind("identifier") ||
-    tokeniser.error("Inheritance lacks a type");
+  const first =
+    inheritanceItem(tokeniser) || tokeniser.error("Inheritance lacks a type");
+  if (!multipleInheritance) {
+    return {
+      colon,
+      extAttrs: first.extAttrs,
+      inheritance: first.inheritance,
+    };
+  }
+  first.tokens.separator = tokeniser.consume(",");
+  if (!first.tokens.separator) {
+    return {
+      colon,
+      inheritance: [first],
+    };
+  }
+  const rest = list(tokeniser, {
+    parser: inheritanceItem,
+    listName: "inheritance-list",
+    allowDangler: false,
+  });
   return {
     colon,
-    extAttrs: extAttrs && extAttrs.length ? extAttrs : undefined,
-    inheritance,
+    inheritance: [first, ...rest],
   };
 }
 
@@ -1640,7 +1673,11 @@ class Container extends Base {
    * @param {*} instance TODO: This should be {T extends Container}, but see https://github.com/microsoft/TypeScript/issues/4628
    * @param {*} args
    */
-  static parse(tokeniser, instance, { inheritable, allowedMembers }) {
+  static parse(
+    tokeniser,
+    instance,
+    { inheritable, allowedMembers, multipleInheritance = false },
+  ) {
     const { tokens, type } = instance;
     tokens.name =
       tokeniser.consumeKind("identifier") ||
@@ -1648,10 +1685,12 @@ class Container extends Base {
     tokeniser.current = instance;
     instance = autoParenter(instance);
     if (inheritable) {
-      const inheritanceParsed = inheritance(tokeniser);
+      const inheritanceParsed = inheritance(tokeniser, multipleInheritance);
       tokens.colon = inheritanceParsed.colon;
       tokens.inheritance = inheritanceParsed.inheritance;
-      instance.inheritanceExtAttrs = inheritanceParsed.extAttrs;
+      if (!multipleInheritance) {
+        instance.inheritanceExtAttrs = inheritanceParsed.extAttrs;
+      }
     }
     tokens.open = tokeniser.consume("{") || tokeniser.error(`Bodyless ${type}`);
     instance.members = [];
@@ -1694,6 +1733,14 @@ class Container extends Base {
     if (!this.tokens.inheritance) {
       return null;
     }
+    if (Array.isArray(this.tokens.inheritance)) {
+      return this.tokens.inheritance.map((it) => {
+        return {
+          extAttrs: it.extAttrs,
+          inheritance: unescape(it.inheritance.value),
+        };
+      });
+    }
     return unescape(this.tokens.inheritance.value);
   }
 
@@ -2069,6 +2116,7 @@ class Interface extends Container {
           [Attribute.parse],
           [Operation.parse],
         ],
+        multipleInheritance: true,
       },
     );
   }
@@ -3015,7 +3063,7 @@ const tokenRe = {
   decimal:
     /-?(?=[0-9]*\.|[0-9]+[eE])(([0-9]+\.[0-9]*|[0-9]*\.[0-9]+)([Ee][-+]?[0-9]+)?|[0-9]+[Ee][-+]?[0-9]+)/y,
   integer: /-?(0([Xx][0-9A-Fa-f]+|[0-7]*)|[1-9][0-9]*)/y,
-  identifier: /[_-]?[A-Za-z](\.?[0-9A-Z_a-z-])*/y,
+  identifier: /[-$_A-Za-z](\.?[$0-9A-Z_a-z-])*/y,
   string: /"(\\"|[^"])*"/y,
   whitespace: /[\t\n\r ]+/y,
   comment: /\/\/.*|\/\*[\s\S]*?\*\//y,
@@ -3123,8 +3171,6 @@ const punctuations = [
 const reserved = [
   // "constructor" is now a keyword
   "_constructor",
-  "toString",
-  "_toString",
 ];
 
 /**
@@ -3152,7 +3198,7 @@ function tokenise(str) {
       line += (currentTrivia.match(/\n/g) || []).length;
       trivia += currentTrivia;
       index -= 1;
-    } else if (/[-0-9.A-Z_a-z]/.test(nextChar)) {
+    } else if (/[-$0-9.A-Z_a-z]/.test(nextChar)) {
       result = attemptTokenMatch("decimal");
       if (result === -1) {
         result = attemptTokenMatch("integer");
@@ -3612,6 +3658,8 @@ class Language {
             case "java": return Language.JAVA;
             case "ts": return Language.TS;
             case "cangjie": return Language.CJ;
+            case "cpp": return Language.CPP;
+            case "kotlin": return Language.KOTLIN;
             default: throw new Error(`Unsupported language ${name}`);
         }
     }
@@ -3621,6 +3669,7 @@ Language.ARKTS = new Language("ArkTS", ".ts", true); // using .ts for ArkTS unti
 Language.JAVA = new Language("Java", ".java", false);
 Language.CPP = new Language("C++", ".cc", false);
 Language.CJ = new Language("CangJie", ".cj", false);
+Language.KOTLIN = new Language("Kotlin", ".kt", false);
 
 /*
  * Copyright (c) 2024 Huawei Device Co., Ltd.
@@ -3649,11 +3698,20 @@ function generateSyntheticIdlNodeName(type) {
         }
     }
     if (isNamedNode(type))
-        return type.name;
+        return type.name.split('.').map(capitalize).join('_');
     if (isOptionalType(type))
         return `Opt_${generateSyntheticIdlNodeName(type.type)}`;
     throw `Can not compute type name of ${IDLKind[type.kind]}`;
 }
+function qualifiedName(decl, languageOrDelimiter, pattern) {
+    if (!isNamedNode(decl))
+        throw new Error("internal error, name required for no-named node");
+    const delimiter = languageOrDelimiter
+        ;
+    if (!isEntry(decl))
+        throw new Error(`Expected to have an IDLEntry, got ${IDLKind[decl.kind]}`);
+    return getQualifiedName(decl, pattern).split(".").join(delimiter);
+}
 function collapseTypes(types, name) {
     const seenNames = new Set();
     const uniqueTypes = types.filter(it => {
@@ -3763,6 +3821,7 @@ var IDLExtendedAttributes;
     IDLExtendedAttributes["DtsName"] = "DtsName";
     IDLExtendedAttributes["DtsTag"] = "DtsTag";
     IDLExtendedAttributes["Entity"] = "Entity";
+    IDLExtendedAttributes["Extends"] = "Extends";
     IDLExtendedAttributes["Import"] = "Import";
     IDLExtendedAttributes["DefaultExport"] = "DefaultExport";
     IDLExtendedAttributes["IndexSignature"] = "IndexSignature";
@@ -3774,10 +3833,12 @@ var IDLExtendedAttributes;
     IDLExtendedAttributes["Protected"] = "Protected";
     IDLExtendedAttributes["Synthetic"] = "Synthetic";
     IDLExtendedAttributes["Throws"] = "Throws";
+    IDLExtendedAttributes["TraceKey"] = "TraceKey";
     IDLExtendedAttributes["TypeArguments"] = "TypeArguments";
     IDLExtendedAttributes["TypeParameters"] = "TypeParameters";
     IDLExtendedAttributes["VerbatimDts"] = "VerbatimDts";
     IDLExtendedAttributes["HandWrittenImplementation"] = "HandWrittenImplementation";
+    IDLExtendedAttributes["ExtraMethod"] = "ExtraMethod";
 })(IDLExtendedAttributes || (IDLExtendedAttributes = {}));
 var IDLAccessorAttribute;
 (function (IDLAccessorAttribute) {
@@ -3794,6 +3855,7 @@ var IDLInterfaceSubkind;
 })(IDLInterfaceSubkind || (IDLInterfaceSubkind = {}));
 /** Updates tree in place! */
 function updateEachChild(node, op, cbLeave) {
+    var _a;
     const old = node;
     node = op(old);
     if (node.kind !== old.kind) {
@@ -3876,7 +3938,11 @@ function updateEachChild(node, op, cbLeave) {
             concrete.typeArguments = concrete.typeArguments.map(it => updateEachChild(it, op, cbLeave));
             break;
         }
-        case IDLKind.ReferenceType:
+        case IDLKind.ReferenceType: {
+            const concrete = node;
+            concrete.typeArguments = (_a = concrete.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => updateEachChild(it, op, cbLeave));
+            break;
+        }
         case IDLKind.TypeParameterType:
         case IDLKind.EnumMember:
         case IDLKind.Import:
@@ -3922,6 +3988,9 @@ function isUnspecifiedGenericType(type) {
 function isEnum$1(type) {
     return type.kind == IDLKind.Enum;
 }
+function isEnumMember(type) {
+    return type.kind == IDLKind.EnumMember;
+}
 function isUnionType(type) {
     return type.kind == IDLKind.UnionType;
 }
@@ -3937,6 +4006,9 @@ function isImport(type) {
 function isMethod(node) {
     return node.kind === IDLKind.Method;
 }
+function isCallback$1(node) {
+    return node.kind === IDLKind.Callback;
+}
 function isInterfaceSubkind(idl) {
     return idl.subkind === IDLInterfaceSubkind.Interface;
 }
@@ -3946,6 +4018,9 @@ function isClassSubkind(idl) {
 function isConstant$1(node) {
     return node.kind === IDLKind.Const;
 }
+function isTypedef$1(node) {
+    return node.kind === IDLKind.Typedef;
+}
 function isType(node) {
     return "_idlTypeBrand" in node;
 }
@@ -3971,17 +4046,11 @@ function createOptionalType(element, nodeInitializer) {
     if (isOptionalType(element) && !nodeInitializer) {
         return element;
     }
+    if (isOptionalType(element)) {
+        return Object.assign(Object.assign({ kind: IDLKind.OptionalType, type: element.type }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlTypeBrand: innerIdlSymbol });
+    }
     return Object.assign(Object.assign({ kind: IDLKind.OptionalType, type: element }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlTypeBrand: innerIdlSymbol });
 }
-/**
- * This placeholder is used when a class has no superclass.
- * Examples:
- *  class definition:               inheritance:
- * `C extends T`                  :  [T]
- * `C implements T`               :  [Top, T]
- * `C extends T implements I, J`  :  [T, I, J]
- */
-const IDLTopType = createReferenceType("__TOP__");
 // must match with toIDLType in deserialize.ts
 const IDLPointerType = createPrimitiveType('pointer');
 const IDLVoidType = createPrimitiveType('void');
@@ -4003,28 +4072,23 @@ const IDLStringType = createPrimitiveType('String');
 const IDLAnyType = createPrimitiveType('any');
 const IDLUndefinedType = createPrimitiveType('undefined');
 const IDLUnknownType = createPrimitiveType('unknown');
-const IDLObjectType = createReferenceType('Object');
+const IDLObjectType = createPrimitiveType('Object');
 const IDLThisType = createPrimitiveType('this');
 const IDLDate = createPrimitiveType('date');
 const IDLBufferType = createPrimitiveType('buffer');
 createContainerType('sequence', [IDLU8Type]);
 const IDLSerializerBuffer = createPrimitiveType('SerializerBuffer');
 // Stub for IdlPeerLibrary
-createPrimitiveType('Function');
-createPrimitiveType('CustomObject');
+const IDLFunctionType = createPrimitiveType('Function');
+const IDLCustomObjectType = createPrimitiveType('CustomObject');
 createPrimitiveType('InteropReturnBuffer');
 function createNamespace(name, members, nodeInitializer) {
     return Object.assign(Object.assign({ kind: IDLKind.Namespace, members: members !== null && members !== void 0 ? members : [], name: name }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
 }
-function isSpecialNodes(node) {
-    return node === IDLTopType
-        || node === IDLObjectType
-        || isPrimitiveType(node);
-}
 function linkParentBack(node) {
     const parentStack = [];
     updateEachChild(node, (node) => {
-        if (isSpecialNodes(node)) {
+        if (isPrimitiveType(node)) {
             return node;
         }
         if (parentStack.length) {
@@ -4037,7 +4101,7 @@ function linkParentBack(node) {
         parentStack.push(node);
         return node;
     }, (node) => {
-        if (isSpecialNodes(node)) {
+        if (isPrimitiveType(node)) {
             return;
         }
         parentStack.pop();
@@ -4115,7 +4179,7 @@ function createFile(entries, fileName, packageClause = [], nodeInitializer) {
     return Object.assign(Object.assign({ kind: IDLKind.File, packageClause, entries: entries, fileName }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol });
 }
 function createImport(clause, name, nodeInitializer) {
-    return Object.assign(Object.assign({ kind: IDLKind.Import, name: name || "", clause }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
+    return Object.assign(Object.assign({ kind: IDLKind.Import, name: name !== null && name !== void 0 ? name : "", clause }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
 }
 function createEnum(name, elements, nodeInitializer) {
     return Object.assign(Object.assign({ kind: IDLKind.Enum, name: name, elements: elements }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
@@ -4169,13 +4233,6 @@ function createConstructor(parameters, returnType, nodeInitializer = {}) {
         returnType }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
 }
 function createCallback(name, parameters, returnType, nodeInitializer = {}, typeParameters = []) {
-    if (returnType === IDLThisType || isReferenceType(returnType) && returnType.name === "this")
-        returnType = IDLAnyType;
-    parameters = parameters.map(it => {
-        if (it.type && isNamedNode(it.type) && (it.type.name === "T" || it.type.name === "this"))
-            return createParameter(it.name, IDLAnyType, it.isOptional, it.isVariadic, { fileName: it.fileName });
-        return it;
-    });
     return Object.assign(Object.assign({ kind: IDLKind.Callback, name, parameters, returnType, typeParameters }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
 }
 function createTypeParameterReference(name, nodeInitializer) {
@@ -4190,7 +4247,7 @@ function createConstant(name, type, value, nodeInitializer = {}) {
         value }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
 }
 function clone(node) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0;
     const make = (node) => node;
     const get = (node) => node;
     switch (node.kind) {
@@ -4198,7 +4255,7 @@ function clone(node) {
             const entry = get(node);
             return make(createInterface(entry.name, entry.subkind, (_a = entry.inheritance) === null || _a === void 0 ? void 0 : _a.map(clone), (_b = entry.constructors) === null || _b === void 0 ? void 0 : _b.map(clone), entry.constants.map(clone), entry.properties.map(clone), entry.methods.map(clone), entry.callables.map(clone), (_c = entry.typeParameters) === null || _c === void 0 ? void 0 : _c.map(it => it), {
                 documentation: node.documentation,
-                extendedAttributes: node.extendedAttributes,
+                extendedAttributes: (_d = node.extendedAttributes) === null || _d === void 0 ? void 0 : _d.slice(),
                 fileName: node.fileName
             }));
         }
@@ -4206,7 +4263,7 @@ function clone(node) {
             const entry = get(node);
             return make(createImport(entry.clause, entry.name, {
                 documentation: entry.documentation,
-                extendedAttributes: entry.extendedAttributes,
+                extendedAttributes: (_e = entry.extendedAttributes) === null || _e === void 0 ? void 0 : _e.slice(),
                 fileName: entry.fileName
             }));
         }
@@ -4214,7 +4271,7 @@ function clone(node) {
             const entry = get(node);
             return make(createCallback(entry.name, entry.parameters.map(clone), clone(entry.returnType), {
                 documentation: entry.documentation,
-                extendedAttributes: entry.extendedAttributes,
+                extendedAttributes: (_f = entry.extendedAttributes) === null || _f === void 0 ? void 0 : _f.slice(),
                 fileName: entry.fileName
             }, entry.typeParameters));
         }
@@ -4222,7 +4279,7 @@ function clone(node) {
             const entry = get(node);
             return make(createConstant(entry.name, clone(entry.type), entry.value, {
                 documentation: entry.documentation,
-                extendedAttributes: entry.extendedAttributes,
+                extendedAttributes: (_g = entry.extendedAttributes) === null || _g === void 0 ? void 0 : _g.slice(),
                 fileName: entry.fileName
             }));
         }
@@ -4230,7 +4287,7 @@ function clone(node) {
             const entry = get(node);
             return make(createProperty(entry.name, clone(entry.type), entry.isReadonly, entry.isStatic, entry.isOptional, {
                 documentation: entry.documentation,
-                extendedAttributes: entry.extendedAttributes,
+                extendedAttributes: (_h = entry.extendedAttributes) === null || _h === void 0 ? void 0 : _h.slice(),
                 fileName: entry.fileName
             }));
         }
@@ -4238,7 +4295,7 @@ function clone(node) {
             const entry = get(node);
             return make(createParameter(entry.name, clone(entry.type), entry.isOptional, entry.isVariadic, {
                 documentation: entry.documentation,
-                extendedAttributes: entry.extendedAttributes,
+                extendedAttributes: (_j = entry.extendedAttributes) === null || _j === void 0 ? void 0 : _j.slice(),
                 fileName: entry.fileName
             }));
         }
@@ -4251,7 +4308,7 @@ function clone(node) {
                 isStatic: entry.isStatic
             }, {
                 documentation: entry.documentation,
-                extendedAttributes: entry.extendedAttributes,
+                extendedAttributes: (_k = entry.extendedAttributes) === null || _k === void 0 ? void 0 : _k.slice(),
                 fileName: entry.fileName
             }, entry.typeParameters));
         }
@@ -4262,7 +4319,7 @@ function clone(node) {
                 isStatic: entry.isStatic
             }, {
                 documentation: entry.documentation,
-                extendedAttributes: entry.extendedAttributes,
+                extendedAttributes: (_l = entry.extendedAttributes) === null || _l === void 0 ? void 0 : _l.slice(),
                 fileName: entry.documentation
             }, entry.typeParameters));
         }
@@ -4270,7 +4327,7 @@ function clone(node) {
             const entry = get(node);
             return make(createConstructor(entry.parameters.map(clone), entry.returnType ? clone(entry.returnType) : undefined, {
                 documentation: entry.documentation,
-                extendedAttributes: entry.extendedAttributes,
+                extendedAttributes: (_m = entry.extendedAttributes) === null || _m === void 0 ? void 0 : _m.slice(),
                 fileName: entry.fileName
             }));
         }
@@ -4278,7 +4335,7 @@ function clone(node) {
             const entry = get(node);
             const cloned = createEnum(entry.name, entry.elements.map(clone), {
                 documentation: entry.documentation,
-                extendedAttributes: entry.extendedAttributes,
+                extendedAttributes: (_o = entry.extendedAttributes) === null || _o === void 0 ? void 0 : _o.slice(),
                 fileName: entry.fileName
             });
             cloned.elements.forEach(it => {
@@ -4290,7 +4347,7 @@ function clone(node) {
             const entry = get(node);
             return make(createEnumMember(entry.name, entry.parent, clone(entry.type), entry.initializer, {
                 documentation: entry.documentation,
-                extendedAttributes: entry.extendedAttributes,
+                extendedAttributes: (_p = entry.extendedAttributes) === null || _p === void 0 ? void 0 : _p.slice(),
                 fileName: entry.fileName
             }));
         }
@@ -4298,7 +4355,7 @@ function clone(node) {
             const entry = get(node);
             return make(createTypedef(entry.name, clone(entry.type), entry.typeParameters, {
                 documentation: entry.documentation,
-                extendedAttributes: entry.extendedAttributes,
+                extendedAttributes: (_q = entry.extendedAttributes) === null || _q === void 0 ? void 0 : _q.slice(),
                 fileName: entry.fileName
             }));
         }
@@ -4309,7 +4366,7 @@ function clone(node) {
             const type = get(node);
             return make(createContainerType(type.containerKind, type.elementType.map(clone), {
                 documentation: type.documentation,
-                extendedAttributes: type.extendedAttributes,
+                extendedAttributes: (_r = type.extendedAttributes) === null || _r === void 0 ? void 0 : _r.slice(),
                 fileName: type.fileName
             }));
         }
@@ -4317,15 +4374,15 @@ function clone(node) {
             const type = get(node);
             return make(createUnspecifiedGenericType(type.name, type.typeArguments.map(clone), {
                 documentation: type.documentation,
-                extendedAttributes: type.extendedAttributes,
+                extendedAttributes: (_s = type.extendedAttributes) === null || _s === void 0 ? void 0 : _s.slice(),
                 fileName: type.fileName
             }));
         }
         case IDLKind.ReferenceType: {
             const type = get(node);
-            return make(createReferenceType(type.name, (_d = type.typeArguments) === null || _d === void 0 ? void 0 : _d.map(clone), {
+            return make(createReferenceType(type.name, (_t = type.typeArguments) === null || _t === void 0 ? void 0 : _t.map(clone), {
                 documentation: type.documentation,
-                extendedAttributes: type.extendedAttributes,
+                extendedAttributes: (_u = type.extendedAttributes) === null || _u === void 0 ? void 0 : _u.slice(),
                 fileName: type.fileName
             }));
         }
@@ -4333,7 +4390,7 @@ function clone(node) {
             const type = get(node);
             return make(createUnionType(type.types.map(clone), type.name, {
                 documentation: type.documentation,
-                extendedAttributes: type.extendedAttributes,
+                extendedAttributes: (_v = type.extendedAttributes) === null || _v === void 0 ? void 0 : _v.slice(),
                 fileName: type.fileName
             }));
         }
@@ -4341,7 +4398,7 @@ function clone(node) {
             const type = get(node);
             return make(createTypeParameterReference(type.name, {
                 documentation: type.documentation,
-                extendedAttributes: type.extendedAttributes,
+                extendedAttributes: (_w = type.extendedAttributes) === null || _w === void 0 ? void 0 : _w.slice(),
                 fileName: type.fileName
             }));
         }
@@ -4349,7 +4406,7 @@ function clone(node) {
             const type = get(node);
             return make(createOptionalType(clone(type.type), {
                 documentation: type.documentation,
-                extendedAttributes: type.extendedAttributes,
+                extendedAttributes: (_x = type.extendedAttributes) === null || _x === void 0 ? void 0 : _x.slice(),
                 fileName: type.fileName
             }));
         }
@@ -4357,7 +4414,7 @@ function clone(node) {
             const entry = get(node);
             return make(createVersion(entry.value, {
                 documentation: entry.documentation,
-                extendedAttributes: entry.extendedAttributes,
+                extendedAttributes: (_y = entry.extendedAttributes) === null || _y === void 0 ? void 0 : _y.slice(),
                 fileName: entry.fileName
             }));
         }
@@ -4365,7 +4422,7 @@ function clone(node) {
             const ns = get(node);
             return make(createNamespace(ns.name, ns.members.map(clone), {
                 documentation: ns.documentation,
-                extendedAttributes: ns.extendedAttributes,
+                extendedAttributes: (_z = ns.extendedAttributes) === null || _z === void 0 ? void 0 : _z.slice(),
                 fileName: ns.fileName
             }));
         }
@@ -4373,7 +4430,7 @@ function clone(node) {
             const file = get(node);
             return make(createFile(file.entries.map(clone), file.fileName, file.packageClause, {
                 documentation: file.documentation,
-                extendedAttributes: file.extendedAttributes,
+                extendedAttributes: (_0 = file.extendedAttributes) === null || _0 === void 0 ? void 0 : _0.slice(),
                 fileName: file.fileName
             }));
         }
@@ -4422,7 +4479,10 @@ function printParameters(parameters) {
     return (_b = (_a = parameters === null || parameters === void 0 ? void 0 : parameters.map(it => nameWithType(it, it.isVariadic, it.isOptional))) === null || _a === void 0 ? void 0 : _a.join(", ")) !== null && _b !== void 0 ? _b : "";
 }
 function printConstructor(idl) {
-    return [`constructor(${printParameters(idl.parameters)});`];
+    return [
+        ...printExtendedAttributes(idl),
+        `constructor(${printParameters(idl.parameters)});`
+    ];
 }
 function nameWithType(idl, isVariadic = false, isOptional = false) {
     const type = printType(idl.type);
@@ -4488,6 +4548,7 @@ const attributesToQuote = new Set([
     IDLExtendedAttributes.DtsTag,
     IDLExtendedAttributes.Import,
     IDLExtendedAttributes.Interfaces,
+    IDLExtendedAttributes.TraceKey,
     IDLExtendedAttributes.TypeArguments,
     IDLExtendedAttributes.TypeParameters,
 ]);
@@ -4556,10 +4617,17 @@ function printCallback(idl) {
         `callback ${idl.name} = ${printReturnType(idl.returnType)} (${printParameters(idl.parameters)});`
     ];
 }
+function printInterfaceInherit(idl) {
+    if (idl.inheritance.length === 0) {
+        return "";
+    }
+    const types = idl.inheritance.map(type => printType(type));
+    return ": " + types.join(', ');
+}
 function printInterface(idl) {
     return [
         ...printExtendedAttributes(idl),
-        `interface ${idl.name}${hasSuperType(idl) ? ": " + printType(idl.inheritance[0]) : ""} {`,
+        `interface ${idl.name}${printInterfaceInherit(idl)} {`,
         // TODO: type system hack!
     ]
         .concat(printedIndentInc)
@@ -4571,15 +4639,6 @@ function printInterface(idl) {
         .concat(printedIndentDec)
         .concat(["};"]);
 }
-function getSuperType(idl) {
-    if (!idl.inheritance)
-        return undefined;
-    const parent = idl.inheritance[0];
-    return parent && parent !== IDLTopType ? parent : undefined;
-}
-function hasSuperType(idl) {
-    return isDefined(getSuperType(idl));
-}
 function printEnumMember(idl) {
     const type = printType(idl.type);
     const initializer = idl.initializer === undefined
@@ -4691,6 +4750,12 @@ function maybeUnwrapOptionalType(type) {
     }
     return type;
 }
+function maybeOptional(type, optional = false) {
+    if (optional) {
+        return createOptionalType(type);
+    }
+    return type;
+}
 const DebugUtils = {
     debugPrintType: (type) => {
         if (isContainerType(type)) {
@@ -4699,6 +4764,16 @@ const DebugUtils = {
         return `[IDLType, name: '${printType(type)}', kind: '${IDLKind[type.kind]}']`;
     },
 };
+function asPromise(type) {
+    if (!type)
+        return undefined;
+    if (!isContainerType(type))
+        return undefined;
+    const container = type;
+    if (!IDLContainerUtils.isPromise(container))
+        return undefined;
+    return container;
+}
 function isStringEnum(decl) {
     return decl.elements.some(e => e.type === IDLStringType);
 }
@@ -4788,13 +4863,10 @@ function warn(message) {
     console.log(`WARNING: ${message}`);
 }
 function forceWriteFile(filePath, content) {
-    path__namespace.dirname(filePath).split(path__namespace.sep).reduce((last, dir) => {
-        const dirPath = path__namespace.join(last, dir);
-        if (!fs__namespace.existsSync(dirPath)) {
-            fs__namespace.mkdirSync(dirPath);
-        }
-        return dirPath;
-    }, ".");
+    const dirPath = path__namespace.dirname(filePath);
+    if (!fs__namespace.existsSync(dirPath)) {
+        fs__namespace.mkdirSync(dirPath, { recursive: true });
+    }
     fs__namespace.writeFileSync(filePath, content);
 }
 function rightmostIndexOf(array, predicate) {
@@ -4834,11 +4906,11 @@ class ValidationBox {
     success() {
         return this.box.success;
     }
-    unwrap() {
+    unwrap(message) {
         if (this.box.success) {
             return this.box.value;
         }
-        throw new Error("");
+        throw new Error(message !== null && message !== void 0 ? message : 'panic');
     }
     error() {
         if (!this.box.success) {
@@ -5134,7 +5206,7 @@ const D = {
                 };
             });
         },
-        null(x) {
+        null() {
             return new ConfigDescriberLeaf(xs => {
                 if (typeof xs === 'object' && xs === null) {
                     return ValidationBox.ok(null);
@@ -5202,6 +5274,9 @@ const ModuleConfigurationSchema = D.object({
     packages: T.stringArray(),
     useFoldersLayout: D.maybe(D.boolean()),
 });
+const HookMethodSchema = D.object({
+    hookName: D.string(),
+});
 D.object({
     TypePrefix: D.string(),
     LibraryPrefix: D.string(),
@@ -5215,6 +5290,9 @@ D.object({
     forceCallback: D.map(D.string(), T.stringArray()).onMerge('replace'),
     forceResource: T.stringArray(),
     forceContext: T.stringArray(),
+    hooks: D.map(D.string(), D.map(D.string(), HookMethodSchema)).onMerge('replace'),
+    externalTypes: D.map(D.string(), D.string()).onMerge('replace'),
+    externalPackages: T.stringArray(),
     moduleName: D.string(),
     modules: D.map(D.string(), ModuleConfigurationSchema).onMerge('replace'),
     globalPackages: T.stringArray()
@@ -5232,6 +5310,9 @@ const defaultCoreConfiguration = {
     forceCallback: new Map(),
     forceResource: [],
     forceContext: [],
+    hooks: new Map(),
+    externalTypes: new Map(),
+    externalPackages: [],
     moduleName: "",
     modules: new Map(),
     globalPackages: []
@@ -5240,6 +5321,10 @@ let currentConfig = defaultCoreConfiguration;
 function generatorConfiguration() {
     return currentConfig;
 }
+function generatorTypePrefix() {
+    const conf = generatorConfiguration();
+    return `${conf.TypePrefix}${conf.LibraryPrefix}`;
+}
 
 /*
  * Copyright (c) 2024 Huawei Device Co., Ltd.
@@ -5495,6 +5580,7 @@ class IndentedPrinter {
         return this.output;
     }
     printTo(file) {
+        fs__namespace.mkdirSync(path.dirname(file), { recursive: true });
         fs__namespace.writeFileSync(file, this.getOutput().join("\n"));
     }
     withIndent(prints) {
@@ -5603,6 +5689,18 @@ class MethodCallExpression extends FunctionCallExpression {
         return `${this.receiver}${this.nullable ? "?" : ""}.${super.asString()}`;
     }
 }
+class MethodStaticCallExpression extends MethodCallExpression {
+    constructor(receiver, method, params, nullable = false) {
+        super(receiver, method, params, nullable);
+        this.receiver = receiver;
+        this.nullable = nullable;
+    }
+}
+class ThisCallExpression extends FunctionCallExpression {
+    constructor(params) {
+        super("this", params);
+    }
+}
 class FieldAccessExpression {
     constructor(receiver, field, nullable = false) {
         this.receiver = receiver;
@@ -5805,6 +5903,9 @@ class LambdaExpression {
                 stmt.write(writer);
             }
         }
+        writer.features.forEach(([feature, module]) => {
+            this.originalWriter.addFeature(feature, module);
+        });
         return (this.body ? ((_a = this.body) === null || _a === void 0 ? void 0 : _a.length) > 1 ? '\n' : '' : '').concat(writer.getOutput()
             .filter(line => line !== "")
             .map(line => indentedBy(line.endsWith('{') || line.endsWith('}') || line.endsWith(';') ? line : `${line};`, 1))
@@ -5842,6 +5943,7 @@ var MethodModifier;
     MethodModifier[MethodModifier["THROWS"] = 8] = "THROWS";
     MethodModifier[MethodModifier["FREE"] = 9] = "FREE";
     MethodModifier[MethodModifier["FORCE_CONTEXT"] = 10] = "FORCE_CONTEXT";
+    MethodModifier[MethodModifier["OVERRIDE"] = 11] = "OVERRIDE";
 })(MethodModifier || (MethodModifier = {}));
 var ClassModifier;
 (function (ClassModifier) {
@@ -5849,6 +5951,11 @@ var ClassModifier;
     ClassModifier[ClassModifier["PRIVATE"] = 1] = "PRIVATE";
     ClassModifier[ClassModifier["PROTECTED"] = 2] = "PROTECTED";
 })(ClassModifier || (ClassModifier = {}));
+var DelegationType;
+(function (DelegationType) {
+    DelegationType[DelegationType["THIS"] = 0] = "THIS";
+    DelegationType[DelegationType["SUPER"] = 1] = "SUPER";
+})(DelegationType || (DelegationType = {}));
 class Method {
     constructor(name, signature, modifiers = undefined, generics) {
         this.name = name;
@@ -5870,6 +5977,7 @@ PrintHint.AsPointer = new PrintHint('AsPointer');
 PrintHint.AsConstPointer = new PrintHint('AsConstPointer');
 PrintHint.AsValue = new PrintHint('AsValue');
 PrintHint.AsConstReference = new PrintHint('AsConstReference');
+PrintHint.AsReference = new PrintHint('AsReference');
 class MethodSignature {
     constructor(returnType, args, defaults = undefined, argsModifiers = undefined, printHints, argNames) {
         this.returnType = returnType;
@@ -5925,11 +6033,15 @@ class LanguageWriter {
         this.resolver = resolver;
         this.language = language;
         this.namespaceStack = [];
+        this.features = [];
     }
     indentDepth() {
         return this.printer.indentDepth();
     }
     maybeSemicolon() { return ";"; }
+    addFeature(feature, module) {
+        this.features.push([feature, module]);
+    }
     // version of makeCast which uses TypeCheck.typeCast<T>(value) call for ETS language writer
     // Use it only if TypeChecker class is added as import to the generated file
     makeTypeCast(value, type, options) {
@@ -5956,12 +6068,17 @@ class LanguageWriter {
         var _a;
         this.writeMethodImplementation(new Method(method.name, method.signature, [MethodModifier.SETTER].concat((_a = method.modifiers) !== null && _a !== void 0 ? _a : [])), op);
     }
+    // Deprecated
+    // Use instead declarationCall parameter in writeConstructorImplementation(...)
     writeSuperCall(params) {
         this.printer.print(`super(${params.join(", ")})${this.maybeSemicolon()}`);
     }
     writeMethodCall(receiver, method, params, nullable = false) {
         this.printer.print(`${receiver}${nullable ? "?" : ""}.${method}(${params.join(", ")})`);
     }
+    writeStaticMethodCall(receiver, method, params, nullable = false) {
+        this.writeMethodCall(receiver, method, params, nullable);
+    }
     writeStatement(stmt) {
         stmt.write(this);
     }
@@ -6012,6 +6129,14 @@ class LanguageWriter {
     makeMethodCall(receiver, method, params, nullable) {
         return new MethodCallExpression(receiver, method, params, nullable);
     }
+    // Deprecated
+    // Use instead declarationCall parameter in writeConstructorImplementation(...) with DelegationType.THIS
+    makeThisCall(params) {
+        return new ThisCallExpression(params);
+    }
+    makeStaticMethodCall(receiver, method, params, nullable) {
+        return new MethodStaticCallExpression(receiver, method, params, nullable);
+    }
     makeFieldAccess(receiver, method, nullable) {
         return new FieldAccessExpression(receiver, method, nullable);
     }
@@ -6193,6 +6318,9 @@ class LanguageWriter {
     makeCallIsObject(value) {
         return this.makeString(`typeof ${value} === "object"`);
     }
+    makeStaticBlock(op) {
+        op(this);
+    }
     instanceOf(convertor, value, _duplicateMembers) {
         return this.makeString(`${value} instanceof ${this.getNodeName(convertor.idlType)}`);
     }
@@ -6209,17 +6337,17 @@ class LanguageWriter {
      * Writes `namespace <namespace> {` and adds extra indent
      * @param namespace Namespace to begin
      */
-    pushNamespace(namespace, ident = true) {
+    pushNamespace(namespace, options) {
         this.print(`namespace ${namespace} {`);
-        if (ident)
+        if (options.ident)
             this.pushIndent();
     }
     /**
      * Writes closing brace of namespace block and removes one level of indent
      */
-    popNamespace(ident = true) {
+    popNamespace(options) {
         this.namespaceStack.pop();
-        if (ident)
+        if (options.ident)
             this.popIndent();
         this.print(`}`);
     }
@@ -6349,6 +6477,27 @@ function convertType(convertor, type) {
         return convertor.convertPrimitiveType(type);
     throw new Error(`Unknown type ${IDLKind[type.kind]}`);
 }
+function convertDeclaration(convertor, decl) {
+    if (isImport(decl))
+        return convertor.convertImport(decl);
+    if (isNamespace(decl))
+        return convertor.convertNamespace(decl);
+    if (isInterface$1(decl))
+        return convertor.convertInterface(decl);
+    if (isEnum$1(decl))
+        return convertor.convertEnum(decl);
+    if (isEnumMember(decl))
+        return convertor.convertEnum(decl.parent);
+    if (isTypedef$1(decl))
+        return convertor.convertTypedef(decl);
+    if (isCallback$1(decl))
+        return convertor.convertCallback(decl);
+    if (isMethod(decl))
+        return convertor.convertMethod(decl);
+    if (isConstant$1(decl))
+        return convertor.convertConstant(decl);
+    throw new Error(`Unknown declaration type ${decl.kind ? IDLKind[decl.kind] : "(undefined kind)"}`);
+}
 
 /*
  * Copyright (c) 2024 Huawei Device Co., Ltd.
@@ -6528,6 +6677,11 @@ class CppPointerPropertyAccessExpression {
         return `${this.expression}->${this.name}`;
     }
 }
+class CPPMethodStaticCallExpression extends MethodStaticCallExpression {
+    asString() {
+        return `${this.receiver}::${this.name}(${this.params.map(it => it.asString()).join(', ')})`;
+    }
+}
 ////////////////////////////////////////////////////////////////
 //                         STATEMENTS                         //
 ////////////////////////////////////////////////////////////////
@@ -6624,8 +6778,13 @@ class CppLanguageWriter extends CLikeLanguageWriter {
     constructor(printer, resolver, typeConvertor, primitivesTypes) {
         super(printer, resolver, Language.CPP);
         this.primitivesTypes = primitivesTypes;
+        this.classMode = 'normal';
+        this.currentClass = [];
         this.typeConvertor = typeConvertor;
     }
+    changeModeTo(mode) {
+        this.classMode = mode;
+    }
     getNodeName(type) {
         return this.typeConvertor.convert(type);
     }
@@ -6633,14 +6792,28 @@ class CppLanguageWriter extends CLikeLanguageWriter {
         var _a;
         return new CppLanguageWriter(new IndentedPrinter(), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.primitivesTypes);
     }
+    writeDeclaration(name, signature, modifiers, postfix) {
+        const realName = this.classMode === 'normal' ? name : `${this.currentClass.at(0)}::${name}`;
+        const newModifiers = this.classMode === 'normal'
+            ? modifiers
+            : (modifiers !== null && modifiers !== void 0 ? modifiers : []).filter(it => it !== MethodModifier.STATIC).concat(MethodModifier.INLINE);
+        super.writeDeclaration(realName, signature, newModifiers, postfix);
+    }
     writeClass(name, op, superClass, interfaces) {
-        const superClasses = (superClass ? [superClass] : []).concat(interfaces !== null && interfaces !== void 0 ? interfaces : []);
-        const extendsClause = superClasses.length > 0 ? ` : ${superClasses.map(c => `public ${c}`).join(", ")}` : '';
-        this.printer.print(`class ${name}${extendsClause} {`);
-        this.pushIndent();
+        if (this.classMode === 'normal') {
+            const superClasses = (superClass ? [superClass] : []).concat(interfaces !== null && interfaces !== void 0 ? interfaces : []);
+            const extendsClause = superClasses.length > 0 ? ` : ${superClasses.map(c => `public ${c}`).join(", ")}` : '';
+            this.printer.print(`class ${name}${extendsClause} {`);
+            this.pushIndent();
+        }
+        if (this.classMode === 'detached') {
+            this.currentClass.push(name);
+        }
         op(this);
-        this.popIndent();
-        this.printer.print(`};`);
+        if (this.classMode === 'normal') {
+            this.popIndent();
+            this.printer.print(`};`);
+        }
     }
     writeInterface(name, op, superInterfaces, generics) {
         throw new Error("Method not implemented.");
@@ -6653,6 +6826,9 @@ class CppLanguageWriter extends CLikeLanguageWriter {
             super.writeMethodCall(receiver, method, params, nullable);
         }
     }
+    writeStaticMethodCall(receiver, method, params, nullable) {
+        this.printer.print(`${receiver}::${method}(${params.join(', ')});`);
+    }
     writeFieldDeclaration(name, type, modifiers, optional, initExpr) {
         let filter = function (modifier_name) {
             return modifier_name !== FieldModifier.STATIC;
@@ -6663,9 +6839,9 @@ class CppLanguageWriter extends CLikeLanguageWriter {
         this.printer.print(`${forceAsNamedNode(type).name} ${name};`);
         this.printer.popIndent();
     }
-    writeConstructorImplementation(className, signature, op, superCall, modifiers) {
-        const superInvocation = superCall
-            ? ` : ${superCall.name}(${superCall.signature.args.map((_, i) => superCall === null || superCall === void 0 ? void 0 : superCall.signature.argName(i)).join(", ")})`
+    writeConstructorImplementation(className, signature, op, delegationCall, modifiers) {
+        const superInvocation = delegationCall
+            ? ` : ${delegationCall.delegationName}(${delegationCall.delegationArgs.map(it => it.asString()).join(", ")})`
             : "";
         const argList = signature.args.map((it, index) => {
             var _a;
@@ -6755,6 +6931,9 @@ class CppLanguageWriter extends CLikeLanguageWriter {
     makeUnionVariantCast(value, type, convertor, index) {
         return this.makeString(`${value}.value${index}`);
     }
+    makeStaticMethodCall(receiver, method, params, nullable) {
+        return new CPPMethodStaticCallExpression(receiver, method, params, nullable);
+    }
     makeLoop(counter, limit, statement) {
         return new CLikeLoopStatement(counter, limit, statement);
     }
@@ -6895,6 +7074,9 @@ class CppLanguageWriter extends CLikeLanguageWriter {
             case PrintHint.AsPointer:
                 postfix = '*';
                 break;
+            case PrintHint.AsReference:
+                postfix = '&';
+                break;
             case PrintHint.AsConstPointer:
                 constModifier = 'const ';
                 postfix = '*';
@@ -7046,10 +7228,11 @@ class TSLanguageWriter extends LanguageWriter {
         this.typeConvertor = typeConvertor;
     }
     maybeSemicolon() { return ""; }
-    pushNamespace(namespace, ident = true) {
+    pushNamespace(namespace, options) {
         this.namespaceStack.push(namespace);
-        this.print(`export namespace ${namespace} {`);
-        if (ident)
+        const declaredPrefix = options.isDeclared ? "declare " : "";
+        this.print(`export ${declaredPrefix}namespace ${namespace} {`);
+        if (options.ident)
             this.pushIndent();
     }
     fork(options) {
@@ -7087,24 +7270,25 @@ class TSLanguageWriter extends LanguageWriter {
         this.popIndent();
         this.printer.print(`}`);
     }
-    writeFunctionDeclaration(name, signature) {
-        this.printer.print(this.generateFunctionDeclaration(name, signature));
+    writeFunctionDeclaration(name, signature, generics) {
+        this.printer.print(this.generateFunctionDeclaration(name, signature, generics));
     }
-    writeFunctionImplementation(name, signature, op) {
-        this.printer.print(`${this.generateFunctionDeclaration(name, signature)} {`);
+    writeFunctionImplementation(name, signature, op, generics) {
+        this.printer.print(`${this.generateFunctionDeclaration(name, signature, generics)} {`);
         this.printer.pushIndent();
         op(this);
         this.printer.popIndent();
         this.printer.print('}');
     }
-    generateFunctionDeclaration(name, signature) {
+    generateFunctionDeclaration(name, signature, generics) {
         const rightmostRegularParameterIndex = rightmostIndexOf(signature.args, it => !isOptionalType(it));
         const args = signature.args.map((it, index) => {
             const optionalToken = isOptionalType(it) && index > rightmostRegularParameterIndex ? '?' : '';
             return `${signature.argName(index)}${optionalToken}: ${this.getNodeName(it)}`;
         });
         const returnType = this.getNodeName(signature.returnType);
-        return `export function ${name}(${args.join(", ")}): ${returnType}`;
+        const typeParams = generics && generics.length ? '<' + (generics === null || generics === void 0 ? void 0 : generics.join(', ')) + '>' : '';
+        return `export function ${name}${typeParams}(${args.join(", ")}): ${returnType}`;
     }
     writeEnum(name, members, options) {
         this.printer.print(`${options.isExport ? "export " : ""}${options.isDeclare ? "declare " : ""}enum ${name} {`);
@@ -7144,11 +7328,13 @@ class TSLanguageWriter extends LanguageWriter {
     writeMethodDeclaration(name, signature, modifiers) {
         this.writeDeclaration(name, signature, true, false, modifiers);
     }
-    writeConstructorImplementation(className, signature, op, superCall, modifiers) {
+    writeConstructorImplementation(className, signature, op, delegationCall, modifiers) {
+        var _a;
         this.writeDeclaration(`${modifiers ? modifiers.map((it) => MethodModifier[it].toLowerCase()).join(' ') + ' ' : ''}constructor`, signature, false, true);
         this.pushIndent();
-        if (superCall) {
-            this.print(`super(${superCall.signature.args.map((_, i) => superCall === null || superCall === void 0 ? void 0 : superCall.signature.argName(i)).join(", ")})`);
+        if (delegationCall) {
+            const delegationType = ((delegationCall === null || delegationCall === void 0 ? void 0 : delegationCall.delegationType) == DelegationType.THIS) ? "this" : "super";
+            this.print(`${delegationType}(${(_a = delegationCall.delegationArgs) === null || _a === void 0 ? void 0 : _a.map(it => it.asString()).join(", ")})`);
         }
         op(this);
         this.popIndent();
@@ -7365,31 +7551,91 @@ class TSLanguageWriter extends LanguageWriter {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var LayoutNodeRole;
-(function (LayoutNodeRole) {
-    LayoutNodeRole[LayoutNodeRole["PEER"] = 0] = "PEER";
-    LayoutNodeRole[LayoutNodeRole["INTERFACE"] = 1] = "INTERFACE";
-    LayoutNodeRole[LayoutNodeRole["GLOBAL"] = 2] = "GLOBAL";
-    LayoutNodeRole[LayoutNodeRole["COMPONENT"] = 3] = "COMPONENT";
-})(LayoutNodeRole || (LayoutNodeRole = {}));
-
-function isInModule(nodeOrPackage, module) {
-    if (typeof nodeOrPackage === 'object')
-        return isInModule(getPackageName(nodeOrPackage), module);
-    return module.packages.some(modulePackage => nodeOrPackage.startsWith(modulePackage));
+class DeclarationNameConvertor {
+    convertImport(decl) {
+        console.warn("Imports are not implemented yet");
+        return decl.name;
+    }
+    convertInterface(decl) {
+        return decl.name;
+    }
+    convertEnum(decl) {
+        return `${getNamespacesPathFor(decl).join('')}${decl.name}`;
+    }
+    convertTypedef(decl) {
+        return decl.name;
+    }
+    convertCallback(decl) {
+        var _a;
+        return (_a = decl.name) !== null && _a !== void 0 ? _a : "MISSING CALLBACK NAME";
+    }
+    convertNamespace(node) {
+        return node.name;
+    }
+    convertMethod(node) {
+        return node.name;
+    }
+    convertConstant(node) {
+        return node.name;
+    }
 }
-function currentModule() {
-    const conf = generatorConfiguration();
-    const result = conf.modules.get(conf.moduleName);
-    if (!result)
-        throw new Error(`Can not determine current module configuration ${conf.moduleName}`);
-    return result;
+DeclarationNameConvertor.I = new DeclarationNameConvertor();
+class TSFeatureNameConvertor extends DeclarationNameConvertor {
+    convertEnum(decl) {
+        const namespace = getNamespacesPathFor(decl).map(it => it.name);
+        if (namespace.length > 0)
+            return namespace[0];
+        return decl.name;
+    }
 }
-function isInCurrentModule(nodeOrPackage) {
-    if (typeof nodeOrPackage === 'string')
-        return isInModule(nodeOrPackage, currentModule());
-    else
-        return isInModule(nodeOrPackage, currentModule());
+TSFeatureNameConvertor.I = new TSFeatureNameConvertor();
+class ETSDeclarationNameConvertor extends DeclarationNameConvertor {
+    convertInterface(decl) {
+        return getQualifiedName(decl, "namespace.name");
+    }
+    convertEnum(decl) {
+        return getQualifiedName(decl, "namespace.name");
+    }
+}
+ETSDeclarationNameConvertor.I = new ETSDeclarationNameConvertor();
+class CJDeclarationNameConvertor extends DeclarationNameConvertor {
+    convertInterface(decl) {
+        return decl.name;
+    }
+    convertEnum(decl) {
+        return decl.name;
+    }
+}
+CJDeclarationNameConvertor.I = new CJDeclarationNameConvertor();
+class ETSFeatureNameConvertor extends DeclarationNameConvertor {
+    convertEnum(decl) {
+        const namespace = getNamespacesPathFor(decl).map(it => it.name);
+        if (namespace.length > 0)
+            return namespace[0];
+        return decl.name;
+    }
+}
+ETSFeatureNameConvertor.I = new ETSFeatureNameConvertor();
+class CJFeatureNameConvertor extends DeclarationNameConvertor {
+    convertEnum(decl) {
+        return decl.name;
+    }
+}
+CJFeatureNameConvertor.I = new CJFeatureNameConvertor();
+class KotlinFeatureNameConvertor extends DeclarationNameConvertor {
+    convertEnum(decl) {
+        return decl.name;
+    }
+}
+KotlinFeatureNameConvertor.I = new KotlinFeatureNameConvertor();
+function createDeclarationNameConvertor(language) {
+    switch (language) {
+        case Language.ARKTS: return ETSDeclarationNameConvertor.I;
+        case Language.JAVA:
+        case Language.CPP:
+        case Language.TS: return DeclarationNameConvertor.I;
+        case Language.CJ:        default: throw new Error(`Language ${language.toString()} is not supported`);
+    }
 }
 
 /*
@@ -7406,84 +7652,1134 @@ function isInCurrentModule(nodeOrPackage) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-({
-    globals: lib$1.lens(lib$1.select.files())
-        .pipe(lib$1.select.nodes())
-        .pipe(lib$1.req('globals', (nodes) => {
-        const result = [];
-        const queue = [nodes];
-        while (queue.length) {
-            const line = {
-                constants: [],
-                methods: []
-            };
-            const next = queue.pop();
-            next.forEach(node => {
-                if (!isInCurrentModule(node))
-                    return;
-                if (isNamespace(node)) {
-                    queue.push(node.members);
-                }
-                if (isConstant$1(node)) {
-                    line.constants.push(node);
-                }
-                if (isMethod(node)) {
-                    line.methods.push(node);
-                }
-            });
-            if (line.constants.length || line.methods.length) {
-                result.push(line);
-            }
+////////////////////////////////////////////////////////////////
+//                         STATEMENTS                         //
+////////////////////////////////////////////////////////////////
+class EtsAssignStatement {
+    constructor(variableName, type, expression, isDeclared = true, isConst = true) {
+        this.variableName = variableName;
+        this.type = type;
+        this.expression = expression;
+        this.isDeclared = isDeclared;
+        this.isConst = isConst;
+    }
+    write(writer) {
+        if (this.isDeclared) {
+            const typeClause = this.type !== undefined ? `: ${writer.getNodeName(this.type)}` : '';
+            const maybeAssign = this.expression !== undefined ? " = " : "";
+            const initValue = this.expression !== undefined ? this.expression : writer.makeString("");
+            writer.print(`${this.isConst ? "const" : "let"} ${this.variableName} ${typeClause}${maybeAssign}${initValue.asString()}`);
         }
-        return result;
-    }))
-});
-
-var IDLValidationDiagnosticsCode;
-(function (IDLValidationDiagnosticsCode) {
-    IDLValidationDiagnosticsCode[IDLValidationDiagnosticsCode["INVALID_EXTENDED_ATTRIBUTE"] = 1000] = "INVALID_EXTENDED_ATTRIBUTE";
-    IDLValidationDiagnosticsCode[IDLValidationDiagnosticsCode["ENUM_IS_NOT_CONSISTENT"] = 1001] = "ENUM_IS_NOT_CONSISTENT";
-    IDLValidationDiagnosticsCode[IDLValidationDiagnosticsCode["REFERENCE_IS_NOT_RESOLVED"] = 1002] = "REFERENCE_IS_NOT_RESOLVED";
-})(IDLValidationDiagnosticsCode || (IDLValidationDiagnosticsCode = {}));
-({
-    [IDLValidationDiagnosticsCode.INVALID_EXTENDED_ATTRIBUTE]: "Invalid extended attribute",
-    [IDLValidationDiagnosticsCode.ENUM_IS_NOT_CONSISTENT]: "Enum includes both string and number values",
-    [IDLValidationDiagnosticsCode.REFERENCE_IS_NOT_RESOLVED]: "Can not resolve reference",
-});
-[
-    IDLTopType.name,
-    IDLObjectType.name,
-];
-
-/*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-function isEnum(node) {
-    return node.type === "enum";
-}
-function isInterface(node) {
-    return node.type === "interface";
+        else {
+            writer.print(`${this.variableName} = ${this.expression.asString()}`);
+        }
+    }
 }
-function isClass(node) {
-    var _a, _b;
-    return isInterface(node)
-        && ((_b = (_a = node.extAttrs.find(it => it.name === "Entity")) === null || _a === void 0 ? void 0 : _a.rhs) === null || _b === void 0 ? void 0 : _b.value) === IDLEntity.Class;
+class ArkTSMapForEachStatement {
+    constructor(map, key, value, op) {
+        this.map = map;
+        this.key = key;
+        this.value = value;
+        this.op = op;
+    }
+    write(writer) {
+        writer.print(`for (const pair of ${this.map}) {`);
+        writer.pushIndent();
+        writer.print(`const ${this.key} = pair[0]`);
+        writer.print(`const ${this.value} = pair[1]`);
+        this.op();
+        writer.popIndent();
+        writer.print(`}`);
+    }
 }
-function isCallback(node) {
-    return node.type === "callback";
+class ArkTSEnumEntityStatement {
+    constructor(enumEntity, options) {
+        this.enumEntity = enumEntity;
+        this.options = options;
+    }
+    write(writer) {
+        let enumName = convertDeclaration(createDeclarationNameConvertor(Language.ARKTS), this.enumEntity);
+        enumName = enumName.split('.').at(-1);
+        const members = this.enumEntity.elements
+            .flatMap((member, index) => {
+            var _a;
+            const initText = (_a = member.initializer) !== null && _a !== void 0 ? _a : index;
+            const isTypeString = typeof initText !== "number";
+            const originalName = getExtAttribute(member, IDLExtendedAttributes.OriginalEnumMemberName);
+            const res = [{
+                    name: member.name,
+                    alias: undefined,
+                    stringId: isTypeString ? initText : undefined,
+                    numberId: initText
+                }];
+            if (originalName !== undefined) {
+                res.push({
+                    name: originalName,
+                    alias: undefined,
+                    stringId: isTypeString ? initText : undefined,
+                    numberId: initText
+                });
+                //TODO: enums do not support member aliases
+                // res.push({
+                //     name: originalName,
+                //     alias: member.name,
+                //     stringId: undefined,
+                //     numberId: initText as number
+                // })
+            }
+            return res;
+        });
+        writer.writeEnum(enumName, members, { isExport: this.options.isExport, isDeclare: this.options.isDeclare });
+    }
 }
-function isTypedef(node) {
+class ETSLambdaExpression extends LambdaExpression {
+    constructor(writer, convertor, signature, resolver, body) {
+        super(writer, signature, resolver, body);
+        this.convertor = convertor;
+    }
+    get statementHasSemicolon() {
+        return false;
+    }
+    asString() {
+        const params = this.signature.args.map((it, i) => {
+            const maybeOptional = isOptionalType(it) ? "?" : "";
+            return `${this.signature.argName(i)}${maybeOptional}: ${this.convertor.convert(it)}`;
+        });
+        // Workaround to fix ArkTS error: SyntaxError: Unexpected token, arrow (=>)
+        // Issue: https://rnd-gitlab-msc.huawei.com/rus-os-team/virtual-machines-and-tools/panda/-/issues/21333
+        let isRetTypeCallback = isCallback$1(this.signature.returnType);
+        if (isReferenceType(this.signature.returnType)) {
+            const resolved = this.resolver.resolveTypeReference(this.signature.returnType);
+            isRetTypeCallback = resolved !== undefined && isCallback$1(resolved);
+        }
+        return `(${params.join(", ")})${isRetTypeCallback
+            ? "" : `:${this.convertor.convert(this.signature.returnType)}`} => { ${this.bodyAsString()} }`;
+    }
+}
+////////////////////////////////////////////////////////////////
+//                           UTILS                            //
+////////////////////////////////////////////////////////////////
+function generateTypeCheckerName(typeName) {
+    typeName = typeName
+        .replaceAll('[]', 'BracketsArray')
+        .split('.').join('_');
+    return `is${typeName.replaceAll('[]', 'Brackets')}`;
+}
+function generateEnumToNumericName(entry) {
+    const typeName = getQualifiedName(entry, "namespace.name").split('.').join('_');
+    return `${typeName}_ToNumeric`;
+}
+function generateEnumFromNumericName(entry) {
+    const typeName = getQualifiedName(entry, "namespace.name").split('.').join('_');
+    return `${typeName}_FromNumeric`;
+}
+function makeArrayTypeCheckCall(valueAccessor, typeName, writer) {
+    return writer.makeMethodCall("TypeChecker", generateTypeCheckerName(typeName), [writer.makeString(valueAccessor)
+    ]);
+}
+////////////////////////////////////////////////////////////////
+//                           WRITER                           //
+////////////////////////////////////////////////////////////////
+class ETSLanguageWriter extends TSLanguageWriter {
+    constructor(printer, resolver, typeConvertor, arrayConvertor) {
+        super(printer, resolver, typeConvertor, Language.ARKTS);
+        this.arrayConvertor = arrayConvertor;
+    }
+    fork(options) {
+        var _a;
+        return new ETSLanguageWriter(new IndentedPrinter(), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.arrayConvertor);
+    }
+    makeAssign(variableName, type, expr, isDeclared = true, isConst = true) {
+        return new EtsAssignStatement(variableName, type, expr, isDeclared, isConst);
+    }
+    makeLambda(signature, body) {
+        return new ETSLambdaExpression(this, this.typeConvertor, signature, this.resolver, body);
+    }
+    makeMapForEach(map, key, value, op) {
+        return new ArkTSMapForEachStatement(map, key, value, op);
+    }
+    makeMapSize(map) {
+        return this.makeString(`${super.makeMapSize(map).asString()}`); // TODO: cast really needed?
+    }
+    get supportedModifiers() {
+        return [MethodModifier.PUBLIC, MethodModifier.PRIVATE, MethodModifier.NATIVE, MethodModifier.STATIC];
+    }
+    runtimeType(param, valueType, value) {
+        super.runtimeType(param, valueType, value);
+    }
+    makeUnionVariantCast(value, type, convertor, index) {
+        return this.makeString(`${value} as ${type}`);
+    }
+    i32FromEnum(value, enumEntry) {
+        if (ETSLanguageWriter.isUseTypeChecker) {
+            return this.makeMethodCall('TypeChecker', generateEnumToNumericName(enumEntry), [value]);
+        }
+        return isStringEnum(enumEntry)
+            ? this.makeMethodCall(value.asString(), 'getOrdinal', [])
+            : this.makeMethodCall(value.asString(), 'valueOf', []);
+    }
+    enumFromI32(value, enumEntry) {
+        const enumName = this.getNodeName(enumEntry);
+        if (ETSLanguageWriter.isUseTypeChecker) {
+            return this.makeMethodCall('TypeChecker', generateEnumFromNumericName(enumEntry), [value]);
+        }
+        return isStringEnum(enumEntry)
+            ? this.makeString(`${enumName}.values()[${value.asString()}]`)
+            : this.makeMethodCall(enumName, 'fromValue', [value]);
+    }
+    makeDiscriminatorFromFields(convertor, value, accessors, duplicates) {
+        if (convertor instanceof AggregateConvertor
+            || convertor instanceof InterfaceConvertor
+            || convertor instanceof MaterializedClassConvertor
+            || convertor instanceof CustomTypeConvertor) {
+            return this.instanceOf(convertor, value, duplicates);
+        }
+        return this.makeString(`${value} instanceof ${convertor.targetType(this)}`);
+    }
+    makeValueFromOption(value, destinationConvertor) {
+        if (isEnum$1(this.resolver.toDeclaration(destinationConvertor.nativeType()))) {
+            return this.makeCast(this.makeString(value), destinationConvertor.idlType);
+        }
+        return super.makeValueFromOption(value, destinationConvertor);
+    }
+    makeIsTypeCall(value, decl) {
+        return makeInterfaceTypeCheckerCall(value, decl.name, decl.properties.map(it => it.name), new Set(), this);
+    }
+    makeEnumEntity(enumEntity, options) {
+        return new ArkTSEnumEntityStatement(enumEntity, {
+            isExport: options === null || options === void 0 ? void 0 : options.isExport,
+            isDeclare: !!(options === null || options === void 0 ? void 0 : options.isDeclare),
+        });
+    }
+    getObjectAccessor(convertor, value, args) {
+        return super.getObjectAccessor(convertor, value, args);
+    }
+    writeMethodCall(receiver, method, params, nullable = false) {
+        // ArkTS does not support - 'this.?'
+        super.writeMethodCall(receiver, method, params, nullable && receiver !== "this");
+    }
+    isQuickType(type) {
+        return asPromise(type) == undefined;
+    }
+    writeNativeMethodDeclaration(method) {
+        if (method.signature.returnType === IDLThisType) {
+            throw new Error('static method can not return this!');
+        }
+        this.writeMethodDeclaration(method.name, method.signature, [MethodModifier.STATIC, MethodModifier.NATIVE]);
+    }
+    makeUnionVariantCondition(convertor, valueName, valueType, type, convertorIndex, runtimeTypeIndex) {
+        if (isEnum$1(this.resolver.toDeclaration(convertor.nativeType()))) {
+            return this.instanceOf(convertor, valueName);
+        }
+        // TODO: in ArkTS SerializerBase.runtimeType returns RuntimeType.OBJECT for enum type and not RuntimeType.NUMBER as in TS
+        if (convertor instanceof UnionConvertor || convertor instanceof OptionConvertor) {
+            // Unwrapping of type
+            const idlType = convertor instanceof UnionConvertor
+                ? convertor.nativeType().types[runtimeTypeIndex]
+                : maybeUnwrapOptionalType(convertor.nativeType());
+            if (idlType !== undefined && isReferenceType(idlType)) {
+                const resolved = this.resolver.resolveTypeReference(idlType);
+                type = resolved != undefined && isEnum$1(resolved) ? RuntimeType[RuntimeType.OBJECT] : type;
+            }
+        }
+        return super.makeUnionVariantCondition(convertor, valueName, valueType, type, convertorIndex);
+    }
+    makeCastCustomObject(customName, isGenericType) {
+        if (isGenericType) {
+            return this.makeCast(this.makeString(customName), IDLObjectType);
+        }
+        return super.makeCastCustomObject(customName, isGenericType);
+    }
+    makeHasOwnProperty(value, valueTypeName, property, propertyTypeName) {
+        return this.makeNaryOp("&&", [
+            this.makeString(`${value} instanceof ${valueTypeName}`),
+            this.makeString(`isInstanceOf("${propertyTypeName}", ${value}.${property})`)
+        ]);
+    }
+    makeEquals(args) {
+        // TODO: Error elimination: 'TypeError: Both operands have to be reference types'
+        // the '==' operator must be used when one of the operands is a reference
+        return super.makeNaryOp('==', args);
+    }
+    makeDiscriminatorConvertor(convertor, value, index) {
+        return this.instanceOf(convertor, value);
+        // Or this ????????
+        // return this.discriminatorFromExpressions(value, RuntimeType.OBJECT, [
+        //     makeEnumTypeCheckerCall(value, this.getNodeName(convertor.idlType), this)
+        // ])
+    }
+    castToInt(value, bitness) {
+        // This fix is used to avoid unnecessary writeInt8(value as int32) call, which is generated if value is already an int32
+        // The explicit cast forces ui2abc to call valueOf on an int, which fails the compilation
+        // TODO Fix this cast
+        if (bitness === 8)
+            return `(${value}).toChar()`;
+        return `(${value}).toInt()`; // FIXME: is there int8 in ARKTS?
+    }
+    castToBoolean(value) { return `${value} ? 1 : 0`; }
+    instanceOf(convertor, value, duplicateMembers) {
+        if (convertor instanceof CustomTypeConvertor) {
+            return makeInterfaceTypeCheckerCall(value, this.getNodeName(convertor.idlType), [], duplicateMembers, this);
+        }
+        if (convertor instanceof InterfaceConvertor || convertor instanceof MaterializedClassConvertor) {
+            return makeInterfaceTypeCheckerCall(value, this.getNodeName(convertor.idlType), convertor.declaration.properties.filter(it => !it.isStatic).map(it => it.name), duplicateMembers, this);
+        }
+        if (convertor instanceof BufferConvertor) {
+            return makeInterfaceTypeCheckerCall(value, this.getNodeName(convertor.idlType), [], new Set(), this);
+        }
+        if (convertor instanceof AggregateConvertor) {
+            return makeInterfaceTypeCheckerCall(value, convertor.aliasName !== undefined ? convertor.aliasName : this.getNodeName(convertor.idlType), convertor.members.map(it => it[0]), duplicateMembers, this);
+        }
+        if (convertor instanceof ArrayConvertor) {
+            return makeArrayTypeCheckCall(value, this.arrayConvertor.convert(convertor.idlType), this);
+        }
+        if (isEnum$1(this.resolver.toDeclaration(convertor.nativeType()))) {
+            return makeEnumTypeCheckerCall(value, this.getNodeName(convertor.idlType), this);
+        }
+        return super.instanceOf(convertor, value, duplicateMembers);
+    }
+    typeInstanceOf(type, value, members) {
+        if (!members || members.length === 0) {
+            throw new Error("At least one member needs to provided to pass it to TypeChecker!");
+        }
+        const prop = members[0];
+        // Use the same typeInstanceOf<T>(...) method to compile the ETS code by two compilers ArkTS and TS
+        return this.makeString(`TypeChecker.typeInstanceOf<${this.getNodeName(type)}>(value, "${prop}")`);
+    }
+    makeTypeCast(value, type, options) {
+        return this.makeString(`TypeChecker.typeCast<${this.getNodeName(type)}>(value)`);
+    }
+    makeCast(value, node, options) {
+        var _a;
+        if (node === IDLI64Type)
+            return this.makeMethodCall(value.asString(), `toLong`, []);
+        if (node === IDLI32Type)
+            return this.makeMethodCall(value.asString(), `toInt`, []);
+        if (node === IDLI8Type)
+            return this.makeMethodCall(value.asString(), `toByte`, []);
+        if (node === IDLF64Type)
+            return this.makeMethodCall(value.asString(), `toDouble`, []);
+        if (node === IDLF32Type)
+            return this.makeMethodCall(value.asString(), `toFloat`, []);
+        return new TSCastExpression(value, `${this.getNodeName(node)}`, (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
+    }
+    static get isUseTypeChecker() { return this._isUseTypeChecker; }
+    static useTypeChecker(isUseTypeChecker, op) {
+        const prevIsUse = this.isReferenceRelativeToNamespaces;
+        this._isUseTypeChecker = isUseTypeChecker;
+        const result = op();
+        this._isUseTypeChecker = prevIsUse;
+        return result;
+    }
+}
+ETSLanguageWriter._isUseTypeChecker = true;
+function makeInterfaceTypeCheckerCall(valueAccessor, interfaceName, allFields, duplicates, writer) {
+    return writer.makeMethodCall("TypeChecker", generateTypeCheckerName(interfaceName), [writer.makeString(valueAccessor),
+        ...allFields.map(it => {
+            return writer.makeString(duplicates.has(it) ? "true" : "false");
+        })
+    ]);
+}
+function makeEnumTypeCheckerCall(valueAccessor, enumName, writer) {
+    return writer.makeMethodCall("TypeChecker", generateTypeCheckerName(enumName), [writer.makeString(valueAccessor)]);
+}
+
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class UnionRuntimeTypeChecker {
+    constructor(convertors) {
+        this.convertors = convertors;
+        this.conflictingConvertors = new Set();
+        this.duplicateMembers = new Set();
+        this.discriminators = [];
+        this.checkConflicts();
+    }
+    checkConflicts() {
+        const runtimeTypeConflicts = new Map();
+        this.convertors.forEach(conv => {
+            conv.runtimeTypes.forEach(rtType => {
+                const convertors = runtimeTypeConflicts.get(rtType);
+                if (convertors)
+                    convertors.push(conv);
+                else
+                    runtimeTypeConflicts.set(rtType, [conv]);
+            });
+        });
+        runtimeTypeConflicts.forEach((convertors, rtType) => {
+            if (convertors.length > 1) {
+                const allMembers = new Set();
+                if (rtType === RuntimeType.OBJECT) {
+                    convertors.forEach(convertor => {
+                        convertor.getMembers().forEach(member => {
+                            if (allMembers.has(member))
+                                this.duplicateMembers.add(member);
+                            allMembers.add(member);
+                        });
+                    });
+                }
+                convertors.forEach(convertor => {
+                    this.conflictingConvertors.add(convertor);
+                });
+            }
+        });
+    }
+    makeDiscriminator(value, convertorIndex, writer) {
+        const convertor = this.convertors[convertorIndex];
+        if (this.conflictingConvertors.has(convertor) && writer.language.needsUnionDiscrimination) {
+            const discriminator = convertor.unionDiscriminator(value, convertorIndex, writer, this.duplicateMembers);
+            this.discriminators.push([discriminator, convertor, convertorIndex]);
+            if (discriminator)
+                return discriminator;
+        }
+        return writer.makeNaryOp("||", convertor.runtimeTypes.map((it, runtimeTypeIndex) => writer.makeNaryOp("==", [
+            writer.makeUnionVariantCondition(convertor, value, `${value}_type`, RuntimeType[it], convertorIndex, runtimeTypeIndex)
+        ])));
+    }
+    reportConflicts(context, writer) {
+        if (this.discriminators.filter(([discriminator, _, __]) => discriminator === undefined).length > 1) {
+            Array.from(this.duplicateMembers).join(",").padEnd(30);
+            this.discriminators.forEach(([discr, conv, n]) => {
+                n.toString().padEnd(3);
+                conv.targetType(writer).padEnd(30);
+                discr ? discr.asString() : "<undefined>";
+            });
+            // throw new Error(report)
+        }
+    }
+}
+
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var LayoutNodeRole;
+(function (LayoutNodeRole) {
+    LayoutNodeRole[LayoutNodeRole["PEER"] = 0] = "PEER";
+    LayoutNodeRole[LayoutNodeRole["INTERFACE"] = 1] = "INTERFACE";
+    LayoutNodeRole[LayoutNodeRole["GLOBAL"] = 2] = "GLOBAL";
+    LayoutNodeRole[LayoutNodeRole["COMPONENT"] = 3] = "COMPONENT";
+    LayoutNodeRole[LayoutNodeRole["SERIALIZER"] = 4] = "SERIALIZER";
+})(LayoutNodeRole || (LayoutNodeRole = {}));
+
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function getSerializerName(declaration) {
+    return `${getQualifiedName(declaration, "namespace.name").split('.').join('_')}_serializer`;
+}
+class BaseArgConvertor {
+    constructor(idlType, runtimeTypes, isScoped, useArray, param) {
+        this.idlType = idlType;
+        this.runtimeTypes = runtimeTypes;
+        this.isScoped = isScoped;
+        this.useArray = useArray;
+        this.param = param;
+    }
+    holdResource(_resourceName, _holder, _writer) { }
+    nativeType() {
+        throw new Error("Define");
+    }
+    isPointerType() {
+        throw new Error("Define");
+    }
+    interopType() {
+        throw new Error("Define");
+    }
+    targetType(writer) {
+        return writer.getNodeName(this.idlType);
+    }
+    unionDiscriminator(value, index, writer, duplicates) {
+        return undefined;
+    }
+    getMembers() { return []; }
+    getObjectAccessor(language, value, args, writer) {
+        if (writer)
+            return writer.getObjectAccessor(this, value, args);
+        return this.useArray && (args === null || args === void 0 ? void 0 : args.index) ? `${value}[${args.index}]` : value;
+    }
+    discriminatorFromFields(value, writer, uniqueFields, nameAccessor, optionalAccessor, duplicates) {
+        if (!uniqueFields || uniqueFields.length === 0)
+            return undefined;
+        const firstNonOptional = uniqueFields.find(it => !optionalAccessor(it));
+        return writer.discriminatorFromExpressions(value, RuntimeType.OBJECT, [
+            writer.makeDiscriminatorFromFields(this, value, firstNonOptional ? [nameAccessor(firstNonOptional)] : uniqueFields.map(it => nameAccessor(it)), duplicates)
+        ]);
+    }
+}
+class UndefinedConvertor extends BaseArgConvertor {
+    constructor(param) {
+        super(IDLUndefinedType, [RuntimeType.UNDEFINED], false, false, param);
+    }
+    convertorArg(param, writer) {
+        return writer.makeUndefined().asString();
+    }
+    convertorSerialize(param, value, printer) { }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        return assigneer(writer.makeUndefined());
+    }
+    nativeType() {
+        return IDLUndefinedType;
+    }
+    interopType() {
+        return IDLUndefinedType;
+    }
+    isPointerType() {
+        return false;
+    }
+}
+class BufferConvertor extends BaseArgConvertor {
+    constructor(param) {
+        super(IDLBufferType, [RuntimeType.OBJECT], false, true, param);
+    }
+    convertorArg(param, _) {
+        return param;
+    }
+    convertorSerialize(param, value, printer) {
+        printer.writeMethodCall(`${param}Serializer`, "writeBuffer", [value]);
+    }
+    convertorDeserialize(_, deserializerName, assigneer, writer) {
+        return assigneer(writer.makeCast(writer.makeString(`${deserializerName}.readBuffer()`), this.idlType, { optional: false }));
+    }
+    nativeType() {
+        return IDLBufferType;
+    }
+    interopType() {
+        return IDLBufferType;
+    }
+    isPointerType() {
+        return true;
+    }
+    unionDiscriminator(value, index, writer, duplicates) {
+        return writer.instanceOf(this, value);
+    }
+}
+class AggregateConvertor extends BaseArgConvertor {
+    constructor(library, param, type, decl) {
+        super(type, [RuntimeType.OBJECT], false, true, param);
+        this.library = library;
+        this.decl = decl;
+        this.members = [];
+        // this.aliasName = ts.isTypeAliasDeclaration(this.type.parent) ? identName(this.type.parent.name) : undefined
+        this.memberConvertors = decl
+            .properties
+            // .filter(ts.isPropertySignature)
+            .map((member, index) => {
+            this.members[index] = [member.name, member.isOptional];
+            return library.typeConvertor(param, member.type, member.isOptional);
+        });
+    }
+    convertorArg(param, writer) {
+        throw new Error("Do not use for aggregates");
+    }
+    convertorSerialize(param, value, printer) {
+        this.memberConvertors.forEach((it, index) => {
+            let memberName = this.members[index][0];
+            let memberAccess = `${value}.${printer.escapeKeyword(memberName)}`;
+            printer.writeStatement(printer.makeAssign(`${value}_${memberName}`, undefined, printer.makeString(memberAccess), true));
+            it.convertorSerialize(param, `${value}_${memberName}`, printer);
+        });
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        const statements = [];
+        if (writer.language === Language.CPP) {
+            statements.push(writer.makeAssign(bufferName, this.idlType, undefined, true, false));
+        }
+        // TODO: Needs to be reworked DeserializerBase.readFunction properly
+        if (writer.language === Language.ARKTS
+            && this.memberConvertors.find(it => it instanceof FunctionConvertor)) {
+            return new BlockStatement([writer.makeThrowError("Not implemented yet")], false);
+        }
+        for (let i = 0; i < this.decl.properties.length; i++) {
+            const prop = this.decl.properties[i];
+            const propConvertor = this.memberConvertors[i];
+            statements.push(propConvertor.convertorDeserialize(`${bufferName}_${prop.name}_buf`, deserializerName, (expr) => {
+                if (writer.language === Language.CPP) {
+                    // prefix initialization for CPP, just easier. Waiting for easy work with nullables
+                    return writer.makeAssign(`${bufferName}.${writer.escapeKeyword(prop.name)}`, undefined, expr, false);
+                }
+                /**
+                 * todo: check UnionType name creation for union of unnamed nodes (isNamedNode() == false)
+                 */
+                const memberType = maybeOptional(prop.type, prop.isOptional);
+                return writer.makeAssign(`${bufferName}_${prop.name}`, memberType, expr, true, true);
+            }, writer));
+        }
+        if (writer.language === Language.CPP) {
+            statements.push(assigneer(writer.makeString(bufferName)));
+        }
+        else if (writer.language == Language.CJ) {
+            const resultExpression = writer.makeString(`${writer.getNodeName(this.idlType)}(${this.decl.properties.map(prop => `${bufferName}_${prop.name}`).join(", ")})`);
+            statements.push(assigneer(resultExpression));
+        }
+        else {
+            const resultExpression = this.makeAssigneeExpression(this.decl.properties.map(prop => {
+                return [prop.name, writer.makeString(`${bufferName}_${prop.name}`)];
+            }), writer);
+            statements.push(assigneer(resultExpression));
+        }
+        return new BlockStatement(statements, false);
+    }
+    makeAssigneeExpression(fields, writer) {
+        const content = fields.map(it => `${it[0]}: ${it[1].asString()}`).join(', ');
+        return writer.makeCast(writer.makeString(`{${content}}`), this.idlType);
+    }
+    nativeType() {
+        return createReferenceType(this.decl);
+    }
+    interopType() {
+        throw new Error("Must never be used");
+    }
+    isPointerType() {
+        return true;
+    }
+    getMembers() {
+        return this.members.map(it => it[0]);
+    }
+    unionDiscriminator(value, index, writer, duplicates) {
+        const uniqueFields = this.members.filter(it => !duplicates.has(it[0]));
+        return this.discriminatorFromFields(value, writer, uniqueFields, it => it[0], it => it[1], duplicates);
+    }
+}
+class InterfaceConvertor extends BaseArgConvertor {
+    constructor(library, name /* change to IDLReferenceType */, param, declaration) {
+        super(createReferenceType(declaration), [RuntimeType.OBJECT], false, true, param);
+        this.library = library;
+        this.declaration = declaration;
+    }
+    convertorArg(param, writer) {
+        throw new Error("Must never be used");
+    }
+    convertorSerialize(param, value, printer) {
+        const accessor = getSerializerName(this.declaration);
+        printer.addFeature(accessor, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
+        printer.writeStaticMethodCall(accessor, 'write', [`${param}Serializer`, value]);
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        const accessor = getSerializerName(this.declaration);
+        writer.addFeature(accessor, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
+        return assigneer(writer.makeStaticMethodCall(accessor, 'read', [writer.makeString(deserializerName)]));
+    }
+    nativeType() {
+        return this.idlType;
+    }
+    interopType() {
+        // Actually shouldn't be used!
+        // throw new Error("Must never be used")
+        return IDLSerializerBuffer;
+    }
+    isPointerType() {
+        return true;
+    }
+    getMembers() {
+        var _a, _b;
+        return (_b = (_a = this.declaration) === null || _a === void 0 ? void 0 : _a.properties.map(it => it.name)) !== null && _b !== void 0 ? _b : [];
+    }
+    unionDiscriminator(value, index, writer, duplicates) {
+        var _a;
+        // Try to figure out interface by examining field sets
+        const uniqueFields = (_a = this.declaration) === null || _a === void 0 ? void 0 : _a.properties.filter(it => !duplicates.has(it.name));
+        return this.discriminatorFromFields(value, writer, uniqueFields, it => it.name, it => it.isOptional, duplicates);
+    }
+}
+class ArrayConvertor extends BaseArgConvertor {
+    constructor(library, param, type, elementType) {
+        super(createContainerType('sequence', [elementType]), [RuntimeType.OBJECT], false, true, param);
+        this.library = library;
+        this.type = type;
+        this.elementType = elementType;
+        this.elementConvertor = library.typeConvertor(param, elementType);
+    }
+    convertorArg(param, writer) {
+        throw new Error("Must never be used");
+    }
+    convertorSerialize(param, value, printer) {
+        // Array length.
+        const valueLength = printer.makeArrayLength(value).asString();
+        const loopCounter = "i";
+        printer.writeMethodCall(`${param}Serializer`, "writeInt32", [printer.castToInt(valueLength, 32)]);
+        printer.writeStatement(printer.makeLoop(loopCounter, valueLength));
+        printer.pushIndent();
+        printer.writeStatement(printer.makeAssign(`${value}_element`, this.elementType, printer.makeArrayAccess(value, loopCounter), true));
+        this.elementConvertor.convertorSerialize(param, `${value}_element`, printer);
+        printer.popIndent();
+        printer.print(`}`);
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        const lengthBuffer = `${bufferName}_length`;
+        const counterBuffer = `${bufferName}_i`;
+        const statements = [];
+        const arrayType = this.idlType;
+        statements.push(writer.makeAssign(lengthBuffer, IDLI32Type, writer.makeString(`${deserializerName}.readInt32()`), true));
+        statements.push(writer.makeAssign(bufferName, arrayType, writer.makeArrayInit(this.type, lengthBuffer), true, false));
+        statements.push(writer.makeArrayResize(bufferName, writer.getNodeName(arrayType), lengthBuffer, deserializerName));
+        statements.push(writer.makeLoop(counterBuffer, lengthBuffer, this.elementConvertor.convertorDeserialize(`${bufferName}_buf`, deserializerName, (expr) => {
+            return writer.makeAssign(writer.makeArrayAccess(bufferName, counterBuffer).asString(), undefined, expr, false);
+        }, writer)));
+        statements.push(assigneer(writer.makeString(bufferName)));
+        return new BlockStatement(statements, false);
+    }
+    nativeType() {
+        return createContainerType('sequence', [this.elementType]);
+    }
+    interopType() {
+        throw new Error("Must never be used");
+    }
+    isPointerType() {
+        return true;
+    }
+    unionDiscriminator(value, index, writer, duplicates) {
+        return writer.discriminatorFromExpressions(value, RuntimeType.OBJECT, [writer.instanceOf(this, value, duplicates)]);
+    }
+    getObjectAccessor(language, value, args) {
+        const array = language === Language.CPP ? ".array" : "";
+        return (args === null || args === void 0 ? void 0 : args.index) ? `${value}${array}${args.index}` : value;
+    }
+}
+class ProxyConvertor extends BaseArgConvertor {
+    constructor(convertor, suggestedReference) {
+        super(suggestedReference ? suggestedReference : convertor.idlType, convertor.runtimeTypes, convertor.isScoped, convertor.useArray, convertor.param);
+        this.convertor = convertor;
+    }
+    convertorArg(param, writer) {
+        return this.convertor.convertorArg(param, writer);
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        return this.convertor.convertorDeserialize(bufferName, deserializerName, assigneer, writer);
+    }
+    convertorSerialize(param, value, printer) {
+        this.convertor.convertorSerialize(param, value, printer);
+    }
+    nativeType() {
+        return this.convertor.nativeType();
+    }
+    interopType() {
+        return this.convertor.interopType();
+    }
+    isPointerType() {
+        return this.convertor.isPointerType();
+    }
+    unionDiscriminator(value, index, writer, duplicates) {
+        return this.convertor.unionDiscriminator(value, index, writer, duplicates);
+    }
+    getMembers() {
+        return this.convertor.getMembers();
+    }
+}
+class CustomTypeConvertor extends BaseArgConvertor {
+    constructor(param, customTypeName, isGenericType, tsType) {
+        super(createReferenceType(tsType !== null && tsType !== void 0 ? tsType : "Object"), [RuntimeType.OBJECT], false, true, param);
+        this.customTypeName = customTypeName;
+        this.isGenericType = isGenericType;
+        warnCustomObject(`${customTypeName}: ${tsType}`);
+    }
+    convertorArg(param, writer) {
+        throw new Error("Must never be used");
+    }
+    /** todo: check */
+    convertorSerialize(param, value, printer) {
+        printer.writeMethodCall(`${param}Serializer`, `writeCustomObject`, [`"${this.customTypeName}"`, printer.makeCastCustomObject(value, this.isGenericType).asString()]);
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        const type = writer.language === Language.CPP
+            ? this.nativeType()
+            : this.idlType;
+        return assigneer(writer.makeCast(writer.makeMethodCall(`${deserializerName}`, "readCustomObject", [writer.makeString(`"${this.customTypeName}"`)]), type, { optional: false }));
+    }
+    nativeType() {
+        return IDLCustomObjectType;
+    }
+    interopType() {
+        throw new Error("Must never be used");
+    }
+    isPointerType() {
+        return true;
+    }
+}
+class OptionConvertor extends BaseArgConvertor {
+    // TODO: be smarter here, and for smth like Length|undefined or number|undefined pass without serializer.
+    constructor(library, param, type) {
+        let conv = library.typeConvertor(param, type);
+        let currentConv = conv;
+        while (currentConv instanceof ProxyConvertor) {
+            currentConv = currentConv.convertor;
+        }
+        if (currentConv instanceof OptionConvertor) {
+            conv = currentConv.typeConvertor;
+        }
+        let runtimeTypes = conv.runtimeTypes;
+        if (!runtimeTypes.includes(RuntimeType.UNDEFINED)) {
+            runtimeTypes.push(RuntimeType.UNDEFINED);
+        }
+        super(createOptionalType(conv.idlType), runtimeTypes, conv.isScoped, true, param);
+        this.type = type;
+        this.typeConvertor = conv;
+    }
+    convertorArg(param, writer) {
+        throw new Error("Must never be used");
+    }
+    convertorSerialize(param, value, printer) {
+        const valueType = `${value}_type`.replaceAll('.', '_');
+        const serializedType = (printer.language == Language.JAVA ? undefined : IDLI32Type);
+        printer.writeStatement(printer.makeAssign(valueType, serializedType, printer.makeRuntimeType(RuntimeType.UNDEFINED), true, false));
+        if (printer.language != Language.CJ && printer.language != Language.KOTLIN) {
+            printer.runtimeType(this, valueType, value);
+            printer.writeMethodCall(`${param}Serializer`, "writeInt8", [printer.castToInt(valueType, 8)]);
+        }
+        printer.print(`if (${printer.makeRuntimeTypeCondition(valueType, false, RuntimeType.UNDEFINED, value).asString()}) {`);
+        printer.pushIndent();
+        if (printer.language == Language.CJ || printer.language == Language.KOTLIN) {
+            printer.writeMethodCall(`${param}Serializer`, "writeInt8", ["RuntimeType.OBJECT.ordinal"]); // everything is object, except None<T>
+        }
+        const valueValue = `${value}_value`.replaceAll('.', '_');
+        printer.writeStatement(printer.makeAssign(valueValue, undefined, printer.makeValueFromOption(value, this.typeConvertor), true));
+        this.typeConvertor.convertorSerialize(param, this.typeConvertor.getObjectAccessor(printer.language, valueValue), printer);
+        printer.popIndent();
+        printer.print(`}`);
+        if (printer.language == Language.CJ || printer.language == Language.KOTLIN) {
+            printer.print('else {');
+            printer.pushIndent();
+            printer.writeMethodCall(`${param}Serializer`, "writeInt8", ["RuntimeType.UNDEFINED.ordinal"]); // undefined
+            printer.popIndent();
+            printer.print('}');
+        }
+    }
+    convertorCArg(param) {
+        throw new Error("Must never be used");
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        const runtimeBufferName = `${bufferName}_runtimeType`;
+        const statements = [];
+        statements.push(writer.makeAssign(runtimeBufferName, undefined, writer.makeCast(writer.makeString(`${deserializerName}.readInt8()`), writer.getRuntimeType()), true));
+        const bufferType = this.nativeType();
+        statements.push(writer.makeAssign(bufferName, bufferType, (writer.language == Language.CJ || writer.language == Language.KOTLIN) ? writer.makeNull() : undefined, true, false));
+        const thenStatement = new BlockStatement([
+            this.typeConvertor.convertorDeserialize(`${bufferName}_`, deserializerName, (expr) => {
+                const receiver = writer.language === Language.CPP
+                    ? `${bufferName}.value` : bufferName;
+                return writer.makeAssign(receiver, undefined, expr, false);
+            }, writer)
+        ]);
+        statements.push(writer.makeSetOptionTag(bufferName, writer.makeCast(writer.makeString(runtimeBufferName), writer.getTagType())));
+        statements.push(writer.makeCondition(writer.makeRuntimeTypeDefinedCheck(runtimeBufferName), thenStatement));
+        statements.push(assigneer(writer.makeString(bufferName)));
+        return writer.makeBlock(statements, false);
+    }
+    nativeType() {
+        return createOptionalType(this.type);
+    }
+    interopType() {
+        return createOptionalType(this.type);
+    }
+    isPointerType() {
+        return true;
+    }
+    getObjectAccessor(language, value, args) {
+        return language === Language.CPP ? `${value}.value` : value;
+    }
+}
+class UnionConvertor extends BaseArgConvertor {
+    constructor(library, param, type) {
+        super(IDLObjectType, [], false, true, param);
+        this.library = library;
+        this.type = type;
+        this.memberConvertors = type.types.map(member => library.typeConvertor(param, member));
+        this.unionChecker = new UnionRuntimeTypeChecker(this.memberConvertors);
+        this.runtimeTypes = this.memberConvertors.flatMap(it => it.runtimeTypes);
+        this.idlType = type;
+    }
+    convertorArg(param, writer) {
+        throw new Error("Do not use for union");
+    }
+    convertorSerialize(param, value, printer) {
+        var _a;
+        printer.writeStatement(printer.makeAssign(`${value}_type`, IDLI32Type, printer.makeUnionTypeDefaultInitializer(), true, false));
+        printer.writeStatement(printer.makeUnionSelector(value, `${value}_type`));
+        this.memberConvertors.forEach((it, index) => {
+            const maybeElse = (index > 0 && this.memberConvertors[index - 1].runtimeTypes.length > 0) ? "else " : "";
+            const conditions = this.unionChecker.makeDiscriminator(value, index, printer);
+            printer.print(`${maybeElse}if (${conditions.asString()}) {`);
+            printer.pushIndent();
+            printer.writeMethodCall(`${param}Serializer`, "writeInt8", [printer.castToInt(index.toString(), 8)]);
+            if (!(it instanceof UndefinedConvertor)) {
+                printer.writeStatement(printer.makeAssign(`${value}_${index}`, undefined, printer.makeUnionVariantCast(it.getObjectAccessor(printer.language, value), printer.getNodeName(it.idlType), it, index), true));
+                it.convertorSerialize(param, `${value}_${index}`, printer);
+            }
+            printer.popIndent();
+            printer.print(`}`);
+        });
+        this.unionChecker.reportConflicts((_a = this.library.getCurrentContext()) !== null && _a !== void 0 ? _a : "<unknown context>", printer);
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        const statements = [];
+        let selectorBuffer = `${bufferName}_selector`;
+        const maybeOptionalUnion = writer.language === Language.CPP || writer.language == Language.CJ
+            ? this.type
+            : createOptionalType(this.type);
+        statements.push(writer.makeAssign(selectorBuffer, IDLI8Type, writer.makeString(`${deserializerName}.readInt8()`), true));
+        statements.push(writer.makeAssign(bufferName, maybeOptionalUnion, undefined, true, false));
+        if (writer.language === Language.CPP)
+            statements.push(writer.makeAssign(`${bufferName}.selector`, undefined, writer.makeString(selectorBuffer), false));
+        const branches = this.memberConvertors.map((it, index) => {
+            const receiver = this.getObjectAccessor(writer.language, bufferName, { index: `${index}` });
+            const expr = writer.makeString(`${selectorBuffer} == ${writer.castToInt(index.toString(), 8)}`);
+            const stmt = new BlockStatement([
+                writer.makeSetUnionSelector(bufferName, `${index}`),
+                it.convertorDeserialize(`${bufferName}_u`, deserializerName, (expr) => {
+                    if (writer.language == Language.CJ) {
+                        return writer.makeAssign(receiver, undefined, writer.makeFunctionCall(writer.getNodeName(this.type), [expr]), false);
+                    }
+                    else {
+                        return writer.makeAssign(receiver, undefined, expr, false);
+                    }
+                }, writer),
+            ], false);
+            return { expr, stmt };
+        });
+        statements.push(writer.makeMultiBranchCondition(branches, writer.makeThrowError(`One of the branches for ${bufferName} has to be chosen through deserialisation.`)));
+        statements.push(assigneer(writer.makeCast(writer.makeString(bufferName), this.nativeType())));
+        return new BlockStatement(statements, false);
+    }
+    nativeType() {
+        return this.type;
+    }
+    interopType() {
+        throw new Error("Union");
+    }
+    isPointerType() {
+        return true;
+    }
+    getObjectAccessor(language, value, args) {
+        return language === Language.CPP && (args === null || args === void 0 ? void 0 : args.index) ? `${value}.value${args.index}` : value;
+    }
+    unionDiscriminator(value, index, writer, duplicates) {
+        const checker = new UnionRuntimeTypeChecker(this.memberConvertors);
+        return writer.makeNaryOp("||", this.memberConvertors.map((_, n) => checker.makeDiscriminator(value, n, writer)));
+    }
+}
+class FunctionConvertor extends BaseArgConvertor {
+    constructor(library, param) {
+        // TODO: pass functions as integers to native side.
+        super(IDLFunctionType, [RuntimeType.FUNCTION], false, false, param);
+        this.library = library;
+    }
+    convertorArg(param, writer) {
+        return writer.language == Language.CPP ? `makeArkFunctionFromId(${param})` : `registerCallback(${param})`;
+    }
+    convertorSerialize(param, value, writer) {
+        writer.writeMethodCall(`${param}Serializer`, "writeFunction", [value]);
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        return assigneer(writer.makeCast(writer.makeString(`${deserializerName}.readFunction()`), IDLFunctionType, { optional: true }));
+    }
+    nativeType() {
+        return IDLFunctionType;
+    }
+    interopType() {
+        return IDLFunctionType;
+    }
+    isPointerType() {
+        return false;
+    }
+}
+class MaterializedClassConvertor extends BaseArgConvertor {
+    constructor(library, param, declaration) {
+        super(createReferenceType(declaration), [RuntimeType.OBJECT], false, false, param);
+        this.library = library;
+        this.declaration = declaration;
+    }
+    convertorArg(param, writer) {
+        switch (writer.language) {
+            case Language.CPP:
+                return `static_cast<${generatorTypePrefix()}${qualifiedName(this.declaration, "_", "namespace.name")}>(${param})`;
+            case Language.JAVA:
+            case Language.CJ:
+                return `MaterializedBase.toPeerPtr(${writer.escapeKeyword(param)})`;
+            default:
+                return `toPeerPtr(${param})`;
+        }
+    }
+    convertorSerialize(param, value, printer) {
+        const accessorRoot = getSerializerName(this.declaration);
+        printer.addFeature(accessorRoot, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
+        printer.writeStaticMethodCall(accessorRoot, 'write', [`${param}Serializer`, value]);
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        const accessorRoot = getSerializerName(this.declaration);
+        writer.addFeature(accessorRoot, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
+        const readStatement = writer.makeCast(writer.makeStaticMethodCall(accessorRoot, "read", [writer.makeString(deserializerName)]), this.declaration);
+        return assigneer(readStatement);
+    }
+    nativeType() {
+        return createReferenceType(this.declaration);
+    }
+    interopType() {
+        return IDLPointerType;
+    }
+    isPointerType() {
+        return false;
+    }
+    unionDiscriminator(value, index, writer, duplicates) {
+        if (isInterface$1(this.declaration)) {
+            if (this.declaration.subkind === IDLInterfaceSubkind.Class) {
+                return writer.discriminatorFromExpressions(value, RuntimeType.OBJECT, [writer.instanceOf(this, value, duplicates)]);
+            }
+            if (this.declaration.subkind === IDLInterfaceSubkind.Interface) {
+                const uniqueFields = this.declaration.properties.filter(it => !duplicates.has(it.name));
+                return this.discriminatorFromFields(value, writer, uniqueFields, it => it.name, it => it.isOptional, duplicates);
+            }
+        }
+    }
+}
+////////////////////////////////////////////////////////////////////////////////
+// UTILS
+const customObjects = new Set();
+function warnCustomObject(type, msg) {
+    if (!customObjects.has(type)) {
+        warn(`Use CustomObject for ${``}type ${type}`);
+        customObjects.add(type);
+    }
+}
+
+function isInModule(nodeOrPackage, module) {
+    if (typeof nodeOrPackage === 'object')
+        return isInModule(getPackageName(nodeOrPackage), module);
+    return module.packages.some(modulePackage => nodeOrPackage.startsWith(modulePackage));
+}
+function currentModule() {
+    const conf = generatorConfiguration();
+    const result = conf.modules.get(conf.moduleName);
+    if (!result)
+        throw new Error(`Can not determine current module configuration ${conf.moduleName}`);
+    return result;
+}
+function isInCurrentModule(nodeOrPackage) {
+    if (typeof nodeOrPackage === 'string')
+        return isInModule(nodeOrPackage, currentModule());
+    else
+        return isInModule(nodeOrPackage, currentModule());
+}
+
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+({
+    globals: lib$1.lens(lib$1.select.files())
+        .pipe(lib$1.select.nodes())
+        .pipe(lib$1.req('globals', (nodes) => {
+        const result = [];
+        const queue = [nodes];
+        while (queue.length) {
+            const line = {
+                constants: [],
+                methods: []
+            };
+            const next = queue.pop();
+            next.forEach(node => {
+                if (!isInCurrentModule(node))
+                    return;
+                if (isNamespace(node)) {
+                    queue.push(node.members);
+                }
+                if (isConstant$1(node)) {
+                    line.constants.push(node);
+                }
+                if (isMethod(node)) {
+                    line.methods.push(node);
+                }
+            });
+            if (line.constants.length || line.methods.length) {
+                result.push(line);
+            }
+        }
+        return result;
+    }))
+});
+
+var IDLValidationDiagnosticsCode;
+(function (IDLValidationDiagnosticsCode) {
+    IDLValidationDiagnosticsCode[IDLValidationDiagnosticsCode["INVALID_EXTENDED_ATTRIBUTE"] = 1000] = "INVALID_EXTENDED_ATTRIBUTE";
+    IDLValidationDiagnosticsCode[IDLValidationDiagnosticsCode["ENUM_IS_NOT_CONSISTENT"] = 1001] = "ENUM_IS_NOT_CONSISTENT";
+    IDLValidationDiagnosticsCode[IDLValidationDiagnosticsCode["REFERENCE_IS_NOT_RESOLVED"] = 1002] = "REFERENCE_IS_NOT_RESOLVED";
+})(IDLValidationDiagnosticsCode || (IDLValidationDiagnosticsCode = {}));
+({
+    [IDLValidationDiagnosticsCode.INVALID_EXTENDED_ATTRIBUTE]: "Invalid extended attribute",
+    [IDLValidationDiagnosticsCode.ENUM_IS_NOT_CONSISTENT]: "Enum includes both string and number values",
+    [IDLValidationDiagnosticsCode.REFERENCE_IS_NOT_RESOLVED]: "Can not resolve reference",
+});
+
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function isEnum(node) {
+    return node.type === "enum";
+}
+function isInterface(node) {
+    return node.type === "interface";
+}
+function isClass(node) {
+    var _a, _b;
+    return isInterface(node)
+        && ((_b = (_a = node.extAttrs.find(it => it.name === "Entity")) === null || _a === void 0 ? void 0 : _a.rhs) === null || _b === void 0 ? void 0 : _b.value) === IDLEntity.Class;
+}
+function isCallback(node) {
+    return node.type === "callback";
+}
+function isTypedef(node) {
     return node.type === "typedef";
 }
 function isDictionary(node) {
@@ -7578,8 +8874,12 @@ function addSyntheticType(name, type) {
     syntheticTypes.set(name, type);
 } // check
 class IDLDeserializer {
-    constructor(info) {
+    enterGenericScope(generics) {
+        this.genericsScopes.push(new Set(generics !== null && generics !== void 0 ? generics : []));
+    }
+    constructor(info, inheritanceMode = 'multiple') {
         this.info = info;
+        this.inheritanceMode = inheritanceMode;
         this.namespacePathNames = [];
         this.currentPackage = [];
         this.genericsScopes = [];
@@ -7606,7 +8906,7 @@ class IDLDeserializer {
     }
     extractGenerics(extAttrs) {
         var _a, _b;
-        return new Set((_b = (_a = this.findExtendedAttribute(extAttrs, IDLExtendedAttributes.TypeParameters)) === null || _a === void 0 ? void 0 : _a.split(",")) === null || _b === void 0 ? void 0 : _b.map(it => this.sanitizeTypeParameter(it)));
+        return (_b = (_a = this.findExtendedAttribute(extAttrs, IDLExtendedAttributes.TypeParameters)) === null || _a === void 0 ? void 0 : _a.split(",")) === null || _b === void 0 ? void 0 : _b.map(it => this.sanitizeTypeParameter(it));
     }
     ///
     toIDLNode(file, node) {
@@ -7652,34 +8952,38 @@ class IDLDeserializer {
         throw new Error(`unexpected node type: ${toString(node)}`);
     }
     toIDLImport(node) {
-        // console.log(node)
         return this.withInfo(node, createImport(node.clause.split("."), node.alias || undefined));
     }
     interfaceSubkind(node) {
         var _a, _b;
         const nodeIDLEntity = (_b = (_a = node.extAttrs.find(it => it.name === "Entity")) === null || _a === void 0 ? void 0 : _a.rhs) === null || _b === void 0 ? void 0 : _b.value;
-        if (nodeIDLEntity == IDLEntity.Class)
-            return IDLInterfaceSubkind.Class;
-        if (nodeIDLEntity == IDLEntity.Interface)
-            return IDLInterfaceSubkind.Interface;
-        if (nodeIDLEntity == IDLEntity.Tuple)
-            return IDLInterfaceSubkind.Tuple;
-        return IDLInterfaceSubkind.Interface;
+        switch (nodeIDLEntity) {
+            case IDLEntity.Class: return IDLInterfaceSubkind.Class;
+            case IDLEntity.Literal: return IDLInterfaceSubkind.AnonymousInterface;
+            case IDLEntity.Tuple: return IDLInterfaceSubkind.Tuple;
+            default: return IDLInterfaceSubkind.Interface;
+        }
     }
     toIDLInterface(file, node) {
-        var _a;
         const generics = this.extractGenerics(node.extAttrs);
-        this.genericsScopes.push(generics);
-        const result = createInterface(node.name, this.interfaceSubkind(node), (() => {
-            var _a, _b;
-            if (!node.inheritance)
+        this.enterGenericScope(generics);
+        const subkind = this.interfaceSubkind(node);
+        const result = createInterface(node.name, subkind, (() => {
+            if (!node.inheritance) {
                 return [];
-            const parentTypeArgs = this.extractTypeArguments(file, (_a = node.inheritanceExtAttrs) !== null && _a !== void 0 ? _a : [], IDLExtendedAttributes.TypeArguments);
-            const parentType = createReferenceType(node.inheritance, parentTypeArgs);
-            parentType.fileName = file;
-            if (node.inheritanceExtAttrs)
-                parentType.extendedAttributes = (_b = this.toExtendedAttributes(node.inheritanceExtAttrs)) === null || _b === void 0 ? void 0 : _b.filter(it => it.name !== IDLExtendedAttributes.TypeArguments);
-            return [parentType];
+            }
+            const implementations = [];
+            node.inheritance.forEach(it => {
+                var _a;
+                const attributes = it.extAttrs;
+                const parentTypeArgs = this.extractTypeArguments(file, attributes !== null && attributes !== void 0 ? attributes : [], IDLExtendedAttributes.TypeArguments);
+                const attrs = (_a = this.toExtendedAttributes(attributes !== null && attributes !== void 0 ? attributes : [])) === null || _a === void 0 ? void 0 : _a.filter(it => it.name !== IDLExtendedAttributes.TypeArguments);
+                const ref = createReferenceType(it.inheritance, parentTypeArgs, {
+                    extendedAttributes: attrs
+                });
+                implementations.push(ref);
+            });
+            return implementations;
         })(), node.members
             .filter(isConstructor)
             .map(it => this.toIDLConstructor(file, it)), [], node.members
@@ -7690,7 +8994,7 @@ class IDLDeserializer {
             .map(it => this.toIDLMethod(file, it, false)), node.members
             .filter(isOperation)
             .filter(it => this.isCallable(it))
-            .map(it => this.toIDLCallable(file, it)), (_a = this.findExtendedAttribute(node.extAttrs, IDLExtendedAttributes.TypeParameters)) === null || _a === void 0 ? void 0 : _a.split(","), {
+            .map(it => this.toIDLCallable(file, it)), generics, {
             fileName: file,
             documentation: this.makeDocs(node),
             extendedAttributes: this.toExtendedAttributes(node.extAttrs),
@@ -7703,7 +9007,7 @@ class IDLDeserializer {
         }
         return result;
     }
-    toIDLType(file, type, extAttrs) {
+    toIDLType(file, type, extAttrs, suggestedName) {
         var _a;
         if (typeof type === "string") {
             // is it IDLStringType?
@@ -7723,7 +9027,7 @@ class IDLDeserializer {
                 types = types.filter(it => it !== IDLUndefinedType);
                 return this.withInfo(type, createOptionalType(collapseTypes(types)));
             }
-            const name = generateSyntheticUnionName(types);
+            const name = suggestedName !== null && suggestedName !== void 0 ? suggestedName : generateSyntheticUnionName(types);
             return this.withInfo(type, createUnionType(types, name));
         }
         if (isSingleTypeDescription(type)) {
@@ -7778,12 +9082,12 @@ class IDLDeserializer {
         throw new Error(`unexpected type: ${toString(type)}`);
     }
     toIDLCallable(file, node) {
-        var _a, _b;
+        var _a;
         if (!node.idlType) {
             throw new Error(`method with no type ${toString(node)}`);
         }
         const generics = this.extractGenerics(node.extAttrs);
-        this.genericsScopes.push(generics);
+        this.enterGenericScope(generics);
         const returnType = this.toIDLType(file, node.idlType, node.extAttrs);
         if (isReferenceType(returnType)) {
             const returnTypeArgs = this.extractTypeArguments(file, node.extAttrs, IDLExtendedAttributes.TypeArguments);
@@ -7795,17 +9099,17 @@ class IDLDeserializer {
         }, {
             documentation: this.makeDocs(node),
             extendedAttributes: this.toExtendedAttributes(node.extAttrs),
-        }, (_b = this.findExtendedAttribute(node.extAttrs, IDLExtendedAttributes.TypeParameters)) === null || _b === void 0 ? void 0 : _b.split(",")));
+        }, generics));
         this.genericsScopes.pop();
         return result;
     }
     toIDLMethod(file, node, isFree = false) {
-        var _a, _b;
+        var _a;
         if (!node.idlType) {
             throw new Error(`method with no type ${toString(node)}`);
         }
         const generics = this.extractGenerics(node.extAttrs);
-        this.genericsScopes.push(generics);
+        this.enterGenericScope(generics);
         const returnType = this.toIDLType(file, node.idlType, node.extAttrs);
         if (isReferenceType(returnType))
             returnType.typeArguments = this.extractTypeArguments(file, node.extAttrs, IDLExtendedAttributes.TypeArguments);
@@ -7817,7 +9121,7 @@ class IDLDeserializer {
         }, {
             documentation: this.makeDocs(node),
             extendedAttributes: this.toExtendedAttributes(node.extAttrs),
-        }, (_b = this.findExtendedAttribute(node.extAttrs, IDLExtendedAttributes.TypeParameters)) === null || _b === void 0 ? void 0 : _b.split(",")));
+        }, generics));
         this.genericsScopes.pop();
         return result;
     }
@@ -7832,22 +9136,24 @@ class IDLDeserializer {
         }));
     }
     toIDLCallback(file, node) {
+        const generics = this.extractGenerics(node.extAttrs);
+        this.enterGenericScope(generics);
         const result = createCallback(node.name, node.arguments.map(it => this.toIDLParameter(file, it)), this.toIDLType(file, node.idlType, undefined), {
             fileName: file,
             extendedAttributes: this.toExtendedAttributes(node.extAttrs),
             documentation: this.makeDocs(node),
-        });
+        }, generics);
         if (node.extAttrs.find(it => it.name === "Synthetic")) {
             const fqName = this.currentPackage.concat(this.namespacePathNames).concat([node.name]).join('.');
             addSyntheticType(fqName, result);
         }
+        this.genericsScopes.pop();
         return this.withInfo(node, result);
     }
     toIDLTypedef(file, node) {
-        var _a;
         const generics = this.extractGenerics(node.extAttrs);
-        this.genericsScopes.push(generics);
-        const result = this.withInfo(node, createTypedef(node.name, this.toIDLType(file, node.idlType, undefined), (_a = this.findExtendedAttribute(node.extAttrs, IDLExtendedAttributes.TypeParameters)) === null || _a === void 0 ? void 0 : _a.split(","), {
+        this.enterGenericScope(generics);
+        const result = this.withInfo(node, createTypedef(node.name, this.toIDLType(file, node.idlType, undefined, node.name), generics, {
             extendedAttributes: this.toExtendedAttributes(node.extAttrs),
             documentation: this.makeDocs(node),
             fileName: file,
@@ -7903,7 +9209,7 @@ class IDLDeserializer {
             initializer = undefined;
         }
         else {
-            throw new Error(`Not representable enum initializer: ${node.default}`);
+            throw new Error(`Not representable enum initializer: ${JSON.stringify(node.default)}. Found in ${file}`);
         }
         return this.withInfo(node, createEnumMember(node.name, parent, this.toIDLType(file, node.idlType, undefined), initializer, {
             extendedAttributes: this.toExtendedAttributes(node.extAttrs),
@@ -7946,17 +9252,39 @@ class IDLDeserializer {
         return node.type === 'import';
     }
     isCallable(node) {
-        return node.extAttrs.some(it => it.name == "Invoke");
+        return node.extAttrs.some(it => it.name == IDLExtendedAttributes.CallSignature);
     }
     ///
+    splitTypeArguments(line) {
+        let buffer = "";
+        let brackets = 0;
+        const result = [];
+        for (const letter of line) {
+            if (letter === ',' && brackets === 0) {
+                result.push(buffer);
+                buffer = '';
+                continue;
+            }
+            if (letter === '<') {
+                brackets += 1;
+            }
+            if (letter === '>') {
+                brackets -= 1;
+            }
+            buffer += letter;
+        }
+        if (buffer.length) {
+            result.push(buffer);
+        }
+        return result;
+    }
     extractTypeArguments(file, extAttrs, attribute) {
         var _a;
         const attr = extAttrs === null || extAttrs === void 0 ? void 0 : extAttrs.find(it => it.name === attribute);
         if (!attr)
             return undefined;
         let value = this.toExtendedAttributeValue(attr);
-        return (_a = value === null || value === void 0 ? void 0 : value.split(",") // TODO need real parsing here. What about "<T, Map<K, Callback<K,R>>, U>"
-        ) === null || _a === void 0 ? void 0 : _a.map(it => { var _a; return this.toIDLType(file, (_a = parseType(it, file)) !== null && _a !== void 0 ? _a : it); });
+        return (_a = this.splitTypeArguments(value)) === null || _a === void 0 ? void 0 : _a.map(it => { var _a; return this.toIDLType(file, (_a = parseType(it.replaceAll('\'', '"'), file)) !== null && _a !== void 0 ? _a : it); });
     }
     constantValue(node) {
         switch (node.value.type) {
@@ -8025,9 +9353,9 @@ class IDLDeserializer {
         return attr ? this.toExtendedAttributeValue(attr) : undefined;
     }
 }
-function toIDLFile(fileName, content) {
+function toIDLFile(fileName, { content, inheritanceMode = 'multiple' } = {}) {
     const lexicalInfo = new Map();
-    const deserializer = new IDLDeserializer(lexicalInfo);
+    const deserializer = new IDLDeserializer(lexicalInfo, inheritanceMode);
     if (undefined === content)
         content = fs__namespace.readFileSync(fileName).toString();
     let packageClause = [];
@@ -8088,10 +9416,10 @@ class BridgesConstructions {
         return `result`;
     }
     static stringConstructor(name) {
-        return `new std::string(${name})`;
+        return `StageArena::strdup(${name})`;
     }
     static sequenceConstructor(first, length) {
-        return `new std::vector<void*>(${first}, ${first} + ${length})`;
+        return `StageArena::cloneVector(${first}, ${length})`;
     }
     static referenceTypeCast(type) {
         return `reinterpret_cast<${type}>`;
@@ -8146,10 +9474,11 @@ class BridgesConstructions {
  * limitations under the License.
  */
 class Config {
-    constructor(ignore, nonNullable, irHack) {
+    constructor(ignore, nonNullable, irHack, fragments) {
         this.ignore = ignore;
         this.nonNullable = nonNullable;
         this.irHack = irHack;
+        this.fragments = fragments;
     }
     static get createPrefix() {
         return `Create`;
@@ -8518,11 +9847,11 @@ class Typechecker {
         if (declaration === undefined || !isInterface$1(declaration)) {
             return false;
         }
-        const parent = declaration.inheritance[0];
-        if (parent === undefined) {
-            return declaration.name === ancestor;
-        }
-        return this.isHeir(parent.name, ancestor);
+        let isHeir = declaration.name === ancestor;
+        declaration.inheritance.forEach(parent => {
+            isHeir || (isHeir = this.isHeir(parent.name, ancestor));
+        });
+        return isHeir;
     }
     isPeer(node) {
         if (node === Config.astNodeCommonAncestor)
@@ -8533,6 +9862,11 @@ class Typechecker {
             return true;
         if (this.isHeir(node, Config.defaultAncestor))
             return true;
+        // TODO: fix
+        if (node === "Program")
+            return true;
+        if (node === "ArkTsConfig")
+            return true;
         return false;
     }
     isReferenceTo(type, isTarget) {
@@ -8556,6 +9890,29 @@ class Typechecker {
             .find(it => it.name === Config.nodeTypeAttribute);
         return (_b = (_a = idlEnum === null || idlEnum === void 0 ? void 0 : idlEnum.elements) === null || _a === void 0 ? void 0 : _a.find(it => { var _a; return ((_a = it.initializer) === null || _a === void 0 ? void 0 : _a.toString()) === value; })) === null || _b === void 0 ? void 0 : _b.name;
     }
+    parent(node) {
+        const parentName = parent(node);
+        if (parentName === undefined)
+            return undefined;
+        const decl = this.findRealDeclaration(parentName);
+        if (decl === undefined)
+            return undefined;
+        if (!isInterface$1(decl))
+            return undefined;
+        return decl;
+    }
+    ancestry(node) {
+        let current = node;
+        const res = [];
+        while (true) {
+            res.push(current);
+            const parent = this.parent(current);
+            if (parent === undefined) {
+                return res;
+            }
+            current = parent;
+        }
+    }
 }
 
 /*
@@ -8607,6 +9964,7 @@ class SingleFilePrinter extends AbstractVisitor {
         this.epilogue();
         return [
             (_b = (_a = this.importer) === null || _a === void 0 ? void 0 : _a.getOutput()) !== null && _b !== void 0 ? _b : [],
+            [''],
             this.writer.getOutput()
         ]
             .flat()
@@ -8693,6 +10051,7 @@ class BaseTypeConvertor {
             case IDLStringType: return this.conversions.string(type);
             case IDLVoidType: return this.conversions.void(type);
             case IDLPointerType: return this.conversions.pointer(type);
+            case IDLUndefinedType: return this.conversions.undefined(type);
         }
         throwException(`unsupported primitive type: ${JSON.stringify(type)}`);
     }
@@ -8758,7 +10117,8 @@ let ReturnTypeConvertor$1 = class ReturnTypeConvertor extends BaseTypeConvertor
             f64: (type) => type,
             boolean: (type) => type,
             void: (type) => type,
-            pointer: (type) => type
+            pointer: (type) => type,
+            undefined: (type) => type
         });
     }
 };
@@ -8779,7 +10139,7 @@ let ReturnTypeConvertor$1 = class ReturnTypeConvertor extends BaseTypeConvertor
 */
 class InteropTypeConvertor extends BaseTypeConvertor {
     constructor(typechecker, heirConversions) {
-        super(typechecker, Object.assign({ enum: (type) => `KInt`, reference: (type) => `KNativePointer`, optional: (type) => throwException(`no nullable allowed at interop level`), i8: (type) => `KBoolean`, iu8: (type) => 'KInt', i16: (type) => `KInt`, i32: (type) => `KInt`, iu32: (type) => `KUInt`, i64: (type) => `KLong`, iu64: (type) => `KULong`, f32: (type) => `KFloat`, f64: (type) => `KDouble`, boolean: (type) => `KBoolean`, void: (type) => `void`, pointer: (type) => `KNativePointer` }, heirConversions));
+        super(typechecker, Object.assign({ enum: (type) => `KInt`, reference: (type) => `KNativePointer`, optional: (type) => throwException(`no nullable allowed at interop level`), undefined: (type) => throwException(`no nullable allowed at interop level`), i8: (type) => `KBoolean`, iu8: (type) => 'KInt', i16: (type) => `KInt`, i32: (type) => `KInt`, iu32: (type) => `KUInt`, i64: (type) => `KLong`, iu64: (type) => `KULong`, f32: (type) => `KFloat`, f64: (type) => `KDouble`, boolean: (type) => `KBoolean`, void: (type) => `void`, pointer: (type) => `KNativePointer` }, heirConversions));
     }
 }
 
@@ -8863,7 +10223,8 @@ class CastTypeConvertor extends BaseTypeConvertor {
             string: (type) => BridgesConstructions.stringCast,
             optional: (type) => throwException(`no optional type allowed at interop level conversion`),
             void: (type) => throwException(`no void typed parameters allowed`),
-            pointer: (type) => throwException(`no pointer typed parameters allowed`)
+            pointer: (type) => throwException(`no pointer typed parameters allowed`),
+            undefined: (type) => throwException(`no undefined typed parameters allowed`)
         });
         this.castToTypeConvertor = new CastToTypeConvertor(this.typechecker);
     }
@@ -8892,7 +10253,8 @@ class CastToTypeConvertor extends BaseTypeConvertor {
             optional: (type) => throwException(`no optional type allowed at interop level conversion`),
             string: (type) => "const char*",
             void: (type) => throwException(`no void typed parameters allowed`),
-            pointer: (type) => throwException(`no pointer typed parameters allowed`)
+            pointer: (type) => throwException(`no pointer typed parameters allowed`),
+            undefined: (type) => throwException(`no undefined typed parameters allowed`)
         });
         this.nativeTypeConvertor = new NativeTypeConvertor(this.typechecker);
     }
@@ -9170,7 +10532,8 @@ class ReturnTypeConvertor extends BaseTypeConvertor {
             boolean: (type) => type,
             string: (type) => type,
             void: (type) => type,
-            pointer: (type) => type
+            pointer: (type) => type,
+            undefined: (type) => throwException(`undefined type is not allowed`)
         });
     }
 }
@@ -9337,6 +10700,9 @@ class PeersConstructions {
     static callPeerMethod(iface, method) {
         return `${iface}.${method}`;
     }
+    static brand(iface) {
+        return `brand${capitalize(iface)}`;
+    }
 }
 
 /*
@@ -9385,6 +10751,14 @@ class Importer {
         this.import(it, `../Es2pandaEnums`);
         return it;
     }
+    withReexportImport(it) {
+        if (this.seen.has(it)) {
+            return it;
+        }
+        this.seen.add(it);
+        this.import(it, "../../reexport-for-generated");
+        return it;
+    }
     import(name, from) {
         this.writer.writeExpressionStatement(this.writer.makeString(PeersConstructions.import(name, path__namespace$1.normalize(path__namespace$1.join(this.dir, from)))));
     }
@@ -9421,7 +10795,8 @@ class TopLevelTypeConvertor extends BaseTypeConvertor {
             f64: heirConversions.number,
             void: heirConversions.void,
             boolean: heirConversions.boolean,
-            pointer: heirConversions.pointer
+            pointer: heirConversions.pointer,
+            undefined: heirConversions.undefined
         }));
     }
 }
@@ -9451,7 +10826,8 @@ class LibraryTypeConvertor extends TopLevelTypeConvertor {
             number: (type) => `number`,
             void: (type) => `void`,
             boolean: (type) => `boolean`,
-            pointer: (type) => `KNativePointer`
+            pointer: (type) => `KNativePointer`,
+            undefined: (type) => `undefined`
         });
     }
 }
@@ -9493,7 +10869,8 @@ class ImporterTypeConvertor extends TopLevelTypeConvertor {
             number: (type) => type,
             boolean: (type) => type,
             void: (type) => type,
-            pointer: (type) => type
+            pointer: (type) => type,
+            undefined: (type) => type
         });
         this.importer = importer;
     }
@@ -9533,6 +10910,7 @@ class BindingParameterTypeConvertor extends TopLevelTypeConvertor {
             void: (type) => (parameter) => parameter,
             pointer: (type) => (parameter) => parameter,
             boolean: (type) => (parameter) => parameter,
+            undefined: (type) => (parameter) => parameter
         });
     }
 }
@@ -9575,6 +10953,7 @@ class BindingReturnValueTypeConvertor extends TopLevelTypeConvertor {
             void: plain,
             pointer: plain,
             boolean: plain,
+            undefined: plain
         });
     }
 }
@@ -9609,6 +10988,7 @@ class PeerPrinter extends SingleFilePrinter {
         return node != this.node;
     }
     constructor(config, idl, node) {
+        var _a;
         super(idl);
         this.config = config;
         this.node = node;
@@ -9616,7 +10996,7 @@ class PeerPrinter extends SingleFilePrinter {
         this.importer = new Importer(this.typechecker, `.`, this.node.name);
         this.bindingParameterTypeConvertor = new BindingParameterTypeConvertor(this.typechecker);
         this.bindingReturnValueTypeConvertor = new BindingReturnValueTypeConvertor(this.typechecker);
-        this.parent = parent(this.node); // ?? throwException(`expected peer to have parent: ${this.node.name}`)
+        this.parent = (_a = parent(this.node)) !== null && _a !== void 0 ? _a : Config.defaultAncestor;
         this.writer = new TSLanguageWriter(new IndentedPrinter(), createEmptyReferenceResolver(), { convert: (node) => composedConvertType(new LibraryTypeConvertor(this.typechecker), new ImporterTypeConvertor(this.importer, this.typechecker), node)
         });
     }
@@ -9626,6 +11006,8 @@ class PeerPrinter extends SingleFilePrinter {
     printBody() {
         this.printConstructor();
         this.printMethods();
+        this.printFragment();
+        this.printBrand();
     }
     printConstructor() {
         this.writer.writeConstructorImplementation(this.node.name, new MethodSignature(IDLVoidType, [
@@ -9666,6 +11048,15 @@ class PeerPrinter extends SingleFilePrinter {
             }
         });
     }
+    printFragment() {
+        const methods = this.config.fragments.getCodeFragment(this.node.name);
+        if (methods !== undefined) {
+            methods.forEach(it => {
+                this.importer.withReexportImport(it.definition);
+                this.writer.writeLines(`${it.name} = ${it.definition}`);
+            });
+        }
+    }
     printGetter(node) {
         this.writer.writeMethodImplementation(new Method(peerMethod(node.name), new MethodSignature(flattenType(node.returnType), []), [MethodModifier.GETTER]), () => {
             this.writer.writeStatement(this.writer.makeReturn(this.makeReturnBindingCall(node)));
@@ -9687,9 +11078,13 @@ class PeerPrinter extends SingleFilePrinter {
     }
     printCreateOrUpdate(node) {
         this.writer.writeMethodImplementation(makeMethod(PeersConstructions.createOrUpdate(this.node.name, node.name), node.parameters.map(it => createParameter(it.name, flattenType(it.type))), flattenType(node.returnType), [MethodModifier.STATIC]), () => {
-            this.writer.writeStatement(this.writer.makeReturn(this.writer.makeNewObject(this.node.name, [
+            const newExpr = this.writer.makeNewObject(this.node.name, [
                 this.writer.makeFunctionCall(this.writer.makeString(PeersConstructions.callBinding(this.node.name, node.name, nodeNamespace(this.node))), this.makeBindingArguments(node.parameters))
-            ])));
+            ]);
+            const isAstNode = this.node.inheritance.some(parent => this.typechecker.isHeir(parent.name, Config.astNodeCommonAncestor));
+            const updateMethodName = 'updateChildren';
+            this.writer.writeStatement(this.writer.makeReturn(isAstNode ?
+                this.writer.makeMethodCall(newExpr.asString(), updateMethodName, []) : newExpr));
         });
     }
     makeBindingArguments(parameters) {
@@ -9709,6 +11104,9 @@ class PeerPrinter extends SingleFilePrinter {
         const qualified = `${this.importer.withEnumImport(Config.nodeTypeAttribute)}.${enumValue}`;
         this.writer.writeExpressionStatements(this.writer.makeString(`if (!nodeByType.has(${qualified})) {`), this.writer.makeString(`    nodeByType.set(${qualified}, (peer: KNativePointer) => new ${this.node.name}(peer))`), this.writer.makeString(`}`));
     }
+    printBrand() {
+        this.writer.writeProperty(PeersConstructions.brand(this.node.name), IDLUndefinedType, [FieldModifier.PROTECTED, FieldModifier.READONLY]);
+    }
 }
 
 /*
@@ -10021,9 +11419,8 @@ class AddContextDeclarationTransformer extends Transformer {
                     name: Config.nodeNamespaceAttribute,
                     value: Config.irNamespace
                 }]
-        })));
-        linkParentBack(file);
-        return file;
+        })), this.file.fileName, this.file.packageClause);
+        return linkParentBack(file);
     }
 }
 
@@ -10209,6 +11606,11 @@ class AstNodeFilterTransformer extends BaseInterfaceFilterTransformer {
             return false;
         if (this.typechecker.isHeir(name, Config.defaultAncestor))
             return false;
+        // TODO: fix
+        if (name === "Program")
+            return false;
+        if (name === "ArkTsConfig")
+            return false;
         console.log(`FILTERED (AST) ${name}`);
         return true;
     }
@@ -12228,6 +13630,35 @@ class NonNullableOptions {
     }
 }
 
+/*
+ * Copyright (c) 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.
+ */
+class CodeFragmentOptions {
+    constructor(filePath) {
+        var _a;
+        this.fragments = [];
+        if (filePath === undefined) {
+            return;
+        }
+        this.fragments = (_a = lib.parse(fs__namespace$1.readFileSync(filePath).toString()).fragments) !== null && _a !== void 0 ? _a : [];
+    }
+    getCodeFragment(name) {
+        var _a;
+        return (_a = this.fragments.find(it => it.interface === name)) === null || _a === void 0 ? void 0 : _a.methods;
+    }
+}
+
 /*
  * Copyright (c) 2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -12248,7 +13679,7 @@ function main() {
     if (options.initialize) {
         new StaticEmitter(options.outputDir, options.pandaSdkPath).emit();
     }
-    new DynamicEmitter(options.outputDir, toIDLFile(path__namespace$1.join(options.pandaSdkPath, pandaSdkIdlFilePath))[0], new Config(new IgnoreOptions(options.optionsFile), new NonNullableOptions(options.optionsFile), new IrHackOptions(options.optionsFile)), options.debug).emit();
+    new DynamicEmitter(options.outputDir, toIDLFile(path__namespace$1.join(options.pandaSdkPath, pandaSdkIdlFilePath), { inheritanceMode: 'single' })[0], new Config(new IgnoreOptions(options.optionsFile), new NonNullableOptions(options.optionsFile), new IrHackOptions(options.optionsFile), new CodeFragmentOptions(options.optionsFile)), options.debug).emit();
 }
 main();
 //# sourceMappingURL=index.js.map