@idlizer/arktscgen 2.1.2 → 2.1.5

package/lib/index.js

@@ -19,11 +19,12 @@
 
 'use strict';
 
+var path$1 = require('node:path');
 var path = require('path');
 var fs = require('fs');
 var ts = require('typescript');
 require('console');
-var path$1 = require('node:path');
+require('node:os');
 var fs$1 = require('node:fs');
 var commander = require('commander');
 
@@ -44,10 +45,10 @@ function _interopNamespaceDefault(e) {
   return Object.freeze(n);
 }
 
+var path__namespace$1 = /*#__PURE__*/_interopNamespaceDefault(path$1);
 var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
 var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
 var ts__namespace = /*#__PURE__*/_interopNamespaceDefault(ts);
-var path__namespace$1 = /*#__PURE__*/_interopNamespaceDefault(path$1);
 var fs__namespace$1 = /*#__PURE__*/_interopNamespaceDefault(fs$1);
 
 /**
@@ -802,9 +803,8 @@ function generic_type(tokeniser, typeName) {
     tokeniser.error(`No opening bracket after ${base.value}`);
   switch (base.value) {
     case "Promise": {
-      if (tokeniser.probe("["))
-        tokeniser.error("Promise type cannot have extended attribute");
       const subtype =
+        type_with_extended_attributes(tokeniser, typeName) ||
         return_type(tokeniser, typeName) ||
         tokeniser.error("Missing Promise subtype");
       ret.subtype.push(subtype);
@@ -2044,7 +2044,7 @@ function static_member(tokeniser) {
   return member;
 }
 
-let Interface$1 = class Interface extends Container {
+class Interface extends Container {
   /**
    * @param {import("../tokeniser.js").Tokeniser} tokeniser
    * @param {import("../tokeniser.js").Token} base
@@ -2151,7 +2151,7 @@ for more information.`;
       yield* checkInterfaceMemberDuplication(defs, this);
     }
   }
-};
+}
 
 function autofixConstructor(interfaceDef, constructorExtAttr) {
   interfaceDef = autoParenter(interfaceDef);
@@ -2620,7 +2620,7 @@ for more information.`;
  * @param {string} identifier
  */
 function unescape(identifier) {
-  return identifier.startsWith("_") ? identifier.slice(1) : identifier;
+  return identifier;
 }
 
 /** @typedef {'callbackInterface'|'dictionary'|'interface'|'mixin'|'namespace'} ExtendableInterfaces */
@@ -2978,7 +2978,7 @@ function parseInterface(tokeniser, options, opts) {
       ...opts,
       ...options?.extensions?.mixin,
     }) ||
-    Interface$1.parse(tokeniser, base, {
+    Interface.parse(tokeniser, base, {
       ...opts,
       ...options?.extensions?.interface,
     }) ||
@@ -3184,6 +3184,7 @@ function tokenise(str) {
           trivia,
           line,
           index,
+          position: lastCharIndex,
         });
         trivia = "";
         lastCharIndex += punctuation.length;
@@ -3210,6 +3211,7 @@ function tokenise(str) {
     trivia,
     line,
     index,
+    position: lastCharIndex,
   });
 
   return tokens;
@@ -3224,7 +3226,14 @@ function tokenise(str) {
     re.lastIndex = lastCharIndex;
     const result = re.exec(str);
     if (result) {
-      tokens.push({ type, value: result[0], trivia, line, index });
+      tokens.push({
+        type,
+        value: result[0],
+        trivia,
+        line,
+        index,
+        position: lastCharIndex,
+      });
       if (!noFlushTrivia) {
         trivia = "";
       }
@@ -3557,6 +3566,20 @@ function parse$1(str, options = {}) {
   return parseByTokens(tokeniser, options);
 }
 
+/**
+ * @param {string} str
+ * @param {string} fileName
+ */
+function parseType(str, fileName) {
+  const tokeniser = new Tokeniser(str);
+  // @ts-ignore (See Tokeniser.source in supplement.d.ts)
+  tokeniser.source.name = fileName;
+  return (
+    type_with_extended_attributes(tokeniser, "type") ||
+    return_type(tokeniser, "return-type")
+  );
+}
+
 /*
  * Copyright (c) 2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -3631,6 +3654,17 @@ function generateSyntheticIdlNodeName(type) {
         return `Opt_${generateSyntheticIdlNodeName(type.type)}`;
     throw `Can not compute type name of ${IDLKind[type.kind]}`;
 }
+function collapseTypes(types, name) {
+    const seenNames = new Set();
+    const uniqueTypes = types.filter(it => {
+        const typeName = printType(it);
+        if (seenNames.has(typeName))
+            return false;
+        seenNames.add(typeName);
+        return true;
+    });
+    return uniqueTypes.length === 1 ? uniqueTypes[0] : createUnionType(uniqueTypes, name);
+}
 function generateSyntheticUnionName(types) {
     return `Union_${types.map(it => generateSyntheticIdlNodeName(it)).join("_").replaceAll(".", "_")}`;
 }
@@ -3730,6 +3764,7 @@ var IDLExtendedAttributes;
     IDLExtendedAttributes["DtsTag"] = "DtsTag";
     IDLExtendedAttributes["Entity"] = "Entity";
     IDLExtendedAttributes["Import"] = "Import";
+    IDLExtendedAttributes["DefaultExport"] = "DefaultExport";
     IDLExtendedAttributes["IndexSignature"] = "IndexSignature";
     IDLExtendedAttributes["Interfaces"] = "Interfaces";
     IDLExtendedAttributes["NativeModule"] = "NativeModule";
@@ -3757,73 +3792,88 @@ var IDLInterfaceSubkind;
     IDLInterfaceSubkind[IDLInterfaceSubkind["AnonymousInterface"] = 2] = "AnonymousInterface";
     IDLInterfaceSubkind[IDLInterfaceSubkind["Tuple"] = 3] = "Tuple";
 })(IDLInterfaceSubkind || (IDLInterfaceSubkind = {}));
-function forEachChild(node, cbEnter, cbLeave) {
-    var _a, _b;
-    cbEnter(node);
+/** Updates tree in place! */
+function updateEachChild(node, op, cbLeave) {
+    const old = node;
+    node = op(old);
+    if (node.kind !== old.kind) {
+        throw new Error("Kinds must be the same!");
+    }
     switch (node.kind) {
-        case IDLKind.File:
-            node.entries.forEach((value) => forEachChild(value, cbEnter, cbLeave));
+        case IDLKind.File: {
+            const concrete = node;
+            concrete.entries = concrete.entries.map(it => updateEachChild(it, op, cbLeave));
             break;
-        case IDLKind.Namespace:
-            node.members.forEach((value) => forEachChild(value, cbEnter, cbLeave));
+        }
+        case IDLKind.Namespace: {
+            const concrete = node;
+            concrete.members = concrete.members.map((it) => updateEachChild(it, op, cbLeave));
             break;
+        }
         case IDLKind.Interface: {
-            let concrete = node;
-            concrete.inheritance.forEach((value) => forEachChild(value, cbEnter, cbLeave));
-            concrete.constructors.forEach((value) => forEachChild(value, cbEnter, cbLeave));
-            concrete.properties.forEach((value) => forEachChild(value, cbEnter, cbLeave));
-            concrete.methods.forEach((value) => forEachChild(value, cbEnter, cbLeave));
-            concrete.callables.forEach((value) => forEachChild(value, cbEnter, cbLeave));
+            const concrete = node;
+            concrete.inheritance = concrete.inheritance.map((it) => updateEachChild(it, op, cbLeave));
+            concrete.constructors = concrete.constructors.map((it) => updateEachChild(it, op, cbLeave));
+            concrete.properties = concrete.properties.map((it) => updateEachChild(it, op, cbLeave));
+            concrete.methods = concrete.methods.map((it) => updateEachChild(it, op, cbLeave));
+            concrete.callables = concrete.callables.map((it) => updateEachChild(it, op, cbLeave));
             break;
         }
         case IDLKind.Method:
         case IDLKind.Callable:
         case IDLKind.Callback:
         case IDLKind.Constructor: {
-            let concrete = node;
-            (_a = concrete.parameters) === null || _a === void 0 ? void 0 : _a.forEach((value) => forEachChild(value, cbEnter, cbLeave));
-            if (concrete.returnType)
-                forEachChild(concrete.returnType, cbEnter, cbLeave);
+            const concrete = node;
+            concrete.parameters = concrete.parameters.map((it) => updateEachChild(it, op, cbLeave));
+            if (concrete.returnType) {
+                concrete.returnType = updateEachChild(concrete.returnType, op, cbLeave);
+            }
             break;
         }
         case IDLKind.UnionType: {
-            let concrete = node;
-            (_b = concrete.types) === null || _b === void 0 ? void 0 : _b.forEach((value) => forEachChild(value, cbEnter, cbLeave));
+            const concrete = node;
+            concrete.types = concrete.types.map((it) => updateEachChild(it, op, cbLeave));
             break;
         }
         case IDLKind.OptionalType: {
-            let concrete = node;
-            forEachChild(concrete.type, cbEnter, cbLeave);
+            const concrete = node;
+            concrete.type = updateEachChild(concrete.type, op, cbLeave);
             break;
         }
         case IDLKind.Const: {
-            forEachChild(node.type, cbEnter, cbLeave);
+            const concrete = node;
+            concrete.type = updateEachChild(concrete.type, op, cbLeave);
             break;
         }
         case IDLKind.Enum: {
-            node.elements.forEach((value) => forEachChild(value, cbEnter, cbLeave));
+            const concrete = node;
+            concrete.elements = concrete.elements.map((it) => updateEachChild(it, op, cbLeave));
             break;
         }
         case IDLKind.Property: {
-            forEachChild(node.type, cbEnter, cbLeave);
+            const concrete = node;
+            concrete.type = updateEachChild(concrete.type, op, cbLeave);
             break;
         }
         case IDLKind.Parameter: {
             const concrete = node;
             if (concrete.type)
-                forEachChild(concrete.type, cbEnter, cbLeave);
+                concrete.type = updateEachChild(concrete.type, op, cbLeave);
             break;
         }
         case IDLKind.Typedef: {
-            forEachChild(node.type, cbEnter, cbLeave);
+            const concrete = node;
+            concrete.type = updateEachChild(concrete.type, op, cbLeave);
             break;
         }
         case IDLKind.ContainerType: {
-            node.elementType.forEach((value) => forEachChild(value, cbEnter, cbLeave));
+            const concrete = node;
+            concrete.elementType = concrete.elementType.map(it => updateEachChild(it, op, cbLeave));
             break;
         }
         case IDLKind.UnspecifiedGenericType: {
-            node.typeArguments.forEach((value) => forEachChild(value, cbEnter, cbLeave));
+            const concrete = node;
+            concrete.typeArguments = concrete.typeArguments.map(it => updateEachChild(it, op, cbLeave));
             break;
         }
         case IDLKind.ReferenceType:
@@ -3837,8 +3887,10 @@ function forEachChild(node, cbEnter, cbLeave) {
             throw new Error(`Unhandled ${node.kind}`);
         }
     }
-    if (cbLeave)
-        cbLeave(node);
+    if (cbLeave) {
+        cbLeave === null || cbLeave === void 0 ? void 0 : cbLeave(node);
+    }
+    return node;
 }
 function isNamedNode(type) {
     return "_idlNamedNodeBrand" in type;
@@ -3879,6 +3931,9 @@ function isTypeParameterType(type) {
 function isInterface$1(node) {
     return node.kind === IDLKind.Interface;
 }
+function isImport(type) {
+    return type.kind == IDLKind.Import;
+}
 function isMethod(node) {
     return node.kind === IDLKind.Method;
 }
@@ -3891,13 +3946,13 @@ 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;
 }
 function isEntry(node) {
     return "_idlEntryBrand" in node;
 }
-function isNamespace$1(node) {
+function isNamespace(node) {
     return node.kind === IDLKind.Namespace;
 }
 function isOptionalType(type) {
@@ -3912,16 +3967,11 @@ function createPrimitiveType(name) {
         _idlNamedNodeBrand: innerIdlSymbol,
     };
 }
-function createOptionalType(element) {
-    if (isOptionalType(element)) {
+function createOptionalType(element, nodeInitializer) {
+    if (isOptionalType(element) && !nodeInitializer) {
         return element;
     }
-    return {
-        kind: IDLKind.OptionalType,
-        type: element,
-        _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.
@@ -3932,6 +3982,7 @@ function createOptionalType(element) {
  * `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');
 const IDLBooleanType = createPrimitiveType('boolean');
@@ -3946,7 +3997,7 @@ const IDLU64Type = createPrimitiveType('u64');
 createPrimitiveType('f16');
 const IDLF32Type = createPrimitiveType('f32');
 const IDLF64Type = createPrimitiveType('f64');
-createPrimitiveType("bigint");
+const IDLBigintType = createPrimitiveType("bigint");
 const IDLNumberType = createPrimitiveType('number');
 const IDLStringType = createPrimitiveType('String');
 const IDLAnyType = createPrimitiveType('any');
@@ -3954,87 +4005,90 @@ const IDLUndefinedType = createPrimitiveType('undefined');
 const IDLUnknownType = createPrimitiveType('unknown');
 const IDLObjectType = createReferenceType('Object');
 const IDLThisType = createPrimitiveType('this');
-createPrimitiveType('date');
+const IDLDate = createPrimitiveType('date');
 const IDLBufferType = createPrimitiveType('buffer');
 createContainerType('sequence', [IDLU8Type]);
 const IDLSerializerBuffer = createPrimitiveType('SerializerBuffer');
 // Stub for IdlPeerLibrary
 createPrimitiveType('Function');
-createPrimitiveType('Length');
 createPrimitiveType('CustomObject');
 createPrimitiveType('InteropReturnBuffer');
-function createNamespace(name, extendedAttributes, fileName) {
-    return {
-        kind: IDLKind.Namespace,
-        members: [],
-        name: name,
-        extendedAttributes,
-        fileName,
-        _idlNodeBrand: innerIdlSymbol,
-        _idlEntryBrand: innerIdlSymbol,
-        _idlNamedNodeBrand: innerIdlSymbol,
-    };
+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 = [];
-    forEachChild(node, (node) => {
-        if (isPrimitiveType(node))
-            return;
-        if (parentStack.length)
-            node.parent = parentStack[parentStack.length - 1];
+    updateEachChild(node, (node) => {
+        if (isSpecialNodes(node)) {
+            return node;
+        }
+        if (parentStack.length) {
+            const top = parentStack[parentStack.length - 1];
+            if (node.parent !== undefined && node.parent !== top) {
+                node = clone(node);
+            }
+            node.parent = top;
+        }
         parentStack.push(node);
+        return node;
     }, (node) => {
-        if (isPrimitiveType(node))
+        if (isSpecialNodes(node)) {
             return;
+        }
         parentStack.pop();
     });
     return node;
 }
-function getNamespacesPathFor(entry) {
-    let iterator = entry.parent;
+function getNamespacesPathFor(node) {
+    let iterator = node.parent;
     const result = [];
     while (iterator) {
-        if (isNamespace$1(iterator))
+        if (isNamespace(iterator))
             result.unshift(iterator);
         iterator = iterator.parent;
     }
     return result;
 }
-function getFileFor(entry) {
-    let iterator = entry;
+function getFileFor(node) {
+    let iterator = node;
     while (iterator) {
         if (isFile(iterator))
             return iterator;
         iterator = iterator.parent;
     }
-    console.warn(`Entry ${JSON.stringify(entry)} does not have IDLFile in parents`);
+    console.warn(`Node ${getQualifiedName(node, "namespace.name")} does not have IDLFile in parents`);
     return undefined;
 }
-function getPackageClause(entry) {
-    let file = getFileFor(entry);
-    return (file === null || file === void 0 ? void 0 : file.packageClause) || [];
+function getPackageClause(node) {
+    var _a;
+    const file = getFileFor(node);
+    return (_a = file === null || file === void 0 ? void 0 : file.packageClause) !== null && _a !== void 0 ? _a : [];
 }
 function getPackageName(node) {
     return getPackageClause(node).join(".");
 }
+function getQualifiedName(a, pattern) {
+    const result = [];
+    if ("package.namespace.name" === pattern)
+        result.push(...getPackageClause(a), ...getNamespacesPathFor(a).map(it => it.name));
+    else if ("namespace.name" === pattern)
+        result.push(...getNamespacesPathFor(a).map(it => it.name));
+    if (isNamedNode(a) && a.name)
+        result.push(a.name);
+    return result.join(".");
+}
 function getFQName(a) {
-    // TODO package name is very dirty now, waiting for Alexander Rekunkov PR
-    // return [...getPackageClause(a), ...getNamespacesPathFor(a).map(it => it.name), a.name].join('.')
-    return [...getNamespacesPathFor(a).map(it => it.name), a.name].join('.');
+    return getQualifiedName(a, "package.namespace.name");
 }
-function createVersion(value, extendedAttributes, fileName) {
-    return {
-        kind: IDLKind.Version,
-        value,
-        name: "version",
-        extendedAttributes,
-        fileName,
-        _idlNodeBrand: innerIdlSymbol,
-        _idlEntryBrand: innerIdlSymbol,
-        _idlNamedNodeBrand: innerIdlSymbol,
-    };
+function createVersion(value, nodeInitializer) {
+    return Object.assign(Object.assign({ kind: IDLKind.Version, value, name: "version" }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
 }
-function createReferenceType(nameOrSource, typeArguments) {
+function createReferenceType(nameOrSource, typeArguments, nodeInitializer) {
     let name;
     if (typeof nameOrSource === 'string') {
         name = nameOrSource;
@@ -4042,54 +4096,23 @@ function createReferenceType(nameOrSource, typeArguments) {
     else {
         name = getFQName(nameOrSource);
     }
-    return {
-        kind: IDLKind.ReferenceType,
-        name,
-        typeArguments,
-        _idlNodeBrand: innerIdlSymbol,
-        _idlTypeBrand: innerIdlSymbol,
-        _idlNamedNodeBrand: innerIdlSymbol,
-    };
+    return Object.assign(Object.assign({ kind: IDLKind.ReferenceType, name,
+        typeArguments }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlTypeBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
 }
-function createUnspecifiedGenericType(name, typeArguments) {
-    return {
-        kind: IDLKind.UnspecifiedGenericType,
-        name,
-        typeArguments,
-        _idlNodeBrand: innerIdlSymbol,
-        _idlTypeBrand: innerIdlSymbol,
-        _idlNamedNodeBrand: innerIdlSymbol,
-    };
+function createUnspecifiedGenericType(name, typeArguments, nodeInitializer) {
+    return Object.assign(Object.assign({ kind: IDLKind.UnspecifiedGenericType, name,
+        typeArguments }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlTypeBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
 }
-function createContainerType(container, element) {
-    return {
-        kind: IDLKind.ContainerType,
-        containerKind: container,
-        elementType: element,
-        _idlNodeBrand: innerIdlSymbol,
-        _idlTypeBrand: innerIdlSymbol,
-    };
+function createContainerType(container, element, nodeInitializer) {
+    return Object.assign(Object.assign({ kind: IDLKind.ContainerType, containerKind: container, elementType: element }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlTypeBrand: innerIdlSymbol });
 }
-function createUnionType(types, name) {
+function createUnionType(types, name, nodeInitializer) {
     if (types.length < 2)
         throw new Error("IDLUnionType should contain at least 2 types");
-    return {
-        kind: IDLKind.UnionType,
-        name: name !== null && name !== void 0 ? name : "Union_" + types.map(it => generateSyntheticIdlNodeName(it)).join("_"),
-        types: types,
-        _idlNodeBrand: innerIdlSymbol,
-        _idlTypeBrand: innerIdlSymbol,
-        _idlNamedNodeBrand: innerIdlSymbol,
-    };
+    return Object.assign(Object.assign({ kind: IDLKind.UnionType, name: name !== null && name !== void 0 ? name : "Union_" + types.map(it => generateSyntheticIdlNodeName(it)).join("_"), types: types }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlTypeBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
 }
-function createFile(entries, fileName, packageClause = []) {
-    return {
-        kind: IDLKind.File,
-        packageClause,
-        entries: entries,
-        fileName,
-        _idlNodeBrand: innerIdlSymbol,
-    };
+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 });
@@ -4155,6 +4178,9 @@ function createCallback(name, parameters, returnType, nodeInitializer = {}, type
     });
     return Object.assign(Object.assign({ kind: IDLKind.Callback, name, parameters, returnType, typeParameters }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
 }
+function createTypeParameterReference(name, nodeInitializer) {
+    return Object.assign(Object.assign({ kind: IDLKind.TypeParameterType, name: name }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlTypeBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
+}
 function createTypedef(name, type, typeParameters = [], nodeInitializer = {}) {
     return Object.assign(Object.assign({ name, type, typeParameters, kind: IDLKind.Typedef }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
 }
@@ -4163,6 +4189,196 @@ function createConstant(name, type, value, nodeInitializer = {}) {
         type,
         value }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
 }
+function clone(node) {
+    var _a, _b, _c, _d;
+    const make = (node) => node;
+    const get = (node) => node;
+    switch (node.kind) {
+        case IDLKind.Interface: {
+            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,
+                fileName: node.fileName
+            }));
+        }
+        case IDLKind.Import: {
+            const entry = get(node);
+            return make(createImport(entry.clause, entry.name, {
+                documentation: entry.documentation,
+                extendedAttributes: entry.extendedAttributes,
+                fileName: entry.fileName
+            }));
+        }
+        case IDLKind.Callback: {
+            const entry = get(node);
+            return make(createCallback(entry.name, entry.parameters.map(clone), clone(entry.returnType), {
+                documentation: entry.documentation,
+                extendedAttributes: entry.extendedAttributes,
+                fileName: entry.fileName
+            }, entry.typeParameters));
+        }
+        case IDLKind.Const: {
+            const entry = get(node);
+            return make(createConstant(entry.name, clone(entry.type), entry.value, {
+                documentation: entry.documentation,
+                extendedAttributes: entry.extendedAttributes,
+                fileName: entry.fileName
+            }));
+        }
+        case IDLKind.Property: {
+            const entry = get(node);
+            return make(createProperty(entry.name, clone(entry.type), entry.isReadonly, entry.isStatic, entry.isOptional, {
+                documentation: entry.documentation,
+                extendedAttributes: entry.extendedAttributes,
+                fileName: entry.fileName
+            }));
+        }
+        case IDLKind.Parameter: {
+            const entry = get(node);
+            return make(createParameter(entry.name, clone(entry.type), entry.isOptional, entry.isVariadic, {
+                documentation: entry.documentation,
+                extendedAttributes: entry.extendedAttributes,
+                fileName: entry.fileName
+            }));
+        }
+        case IDLKind.Method: {
+            const entry = get(node);
+            return make(createMethod(entry.name, entry.parameters.map(clone), clone(entry.returnType), {
+                isAsync: entry.isAsync,
+                isFree: entry.isFree,
+                isOptional: entry.isOptional,
+                isStatic: entry.isStatic
+            }, {
+                documentation: entry.documentation,
+                extendedAttributes: entry.extendedAttributes,
+                fileName: entry.fileName
+            }, entry.typeParameters));
+        }
+        case IDLKind.Callable: {
+            const entry = get(node);
+            return make(createCallable(entry.name, entry.parameters.map(clone), clone(entry.returnType), {
+                isAsync: entry.isAsync,
+                isStatic: entry.isStatic
+            }, {
+                documentation: entry.documentation,
+                extendedAttributes: entry.extendedAttributes,
+                fileName: entry.documentation
+            }, entry.typeParameters));
+        }
+        case IDLKind.Constructor: {
+            const entry = get(node);
+            return make(createConstructor(entry.parameters.map(clone), entry.returnType ? clone(entry.returnType) : undefined, {
+                documentation: entry.documentation,
+                extendedAttributes: entry.extendedAttributes,
+                fileName: entry.fileName
+            }));
+        }
+        case IDLKind.Enum: {
+            const entry = get(node);
+            const cloned = createEnum(entry.name, entry.elements.map(clone), {
+                documentation: entry.documentation,
+                extendedAttributes: entry.extendedAttributes,
+                fileName: entry.fileName
+            });
+            cloned.elements.forEach(it => {
+                it.parent = cloned;
+            });
+            return make(cloned);
+        }
+        case IDLKind.EnumMember: {
+            const entry = get(node);
+            return make(createEnumMember(entry.name, entry.parent, clone(entry.type), entry.initializer, {
+                documentation: entry.documentation,
+                extendedAttributes: entry.extendedAttributes,
+                fileName: entry.fileName
+            }));
+        }
+        case IDLKind.Typedef: {
+            const entry = get(node);
+            return make(createTypedef(entry.name, clone(entry.type), entry.typeParameters, {
+                documentation: entry.documentation,
+                extendedAttributes: entry.extendedAttributes,
+                fileName: entry.fileName
+            }));
+        }
+        case IDLKind.PrimitiveType: {
+            return node;
+        }
+        case IDLKind.ContainerType: {
+            const type = get(node);
+            return make(createContainerType(type.containerKind, type.elementType.map(clone), {
+                documentation: type.documentation,
+                extendedAttributes: type.extendedAttributes,
+                fileName: type.fileName
+            }));
+        }
+        case IDLKind.UnspecifiedGenericType: {
+            const type = get(node);
+            return make(createUnspecifiedGenericType(type.name, type.typeArguments.map(clone), {
+                documentation: type.documentation,
+                extendedAttributes: type.extendedAttributes,
+                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), {
+                documentation: type.documentation,
+                extendedAttributes: type.extendedAttributes,
+                fileName: type.fileName
+            }));
+        }
+        case IDLKind.UnionType: {
+            const type = get(node);
+            return make(createUnionType(type.types.map(clone), type.name, {
+                documentation: type.documentation,
+                extendedAttributes: type.extendedAttributes,
+                fileName: type.fileName
+            }));
+        }
+        case IDLKind.TypeParameterType: {
+            const type = get(node);
+            return make(createTypeParameterReference(type.name, {
+                documentation: type.documentation,
+                extendedAttributes: type.extendedAttributes,
+                fileName: type.fileName
+            }));
+        }
+        case IDLKind.OptionalType: {
+            const type = get(node);
+            return make(createOptionalType(clone(type.type), {
+                documentation: type.documentation,
+                extendedAttributes: type.extendedAttributes,
+                fileName: type.fileName
+            }));
+        }
+        case IDLKind.Version: {
+            const entry = get(node);
+            return make(createVersion(entry.value, {
+                documentation: entry.documentation,
+                extendedAttributes: entry.extendedAttributes,
+                fileName: entry.fileName
+            }));
+        }
+        case IDLKind.Namespace: {
+            const ns = get(node);
+            return make(createNamespace(ns.name, ns.members.map(clone), {
+                documentation: ns.documentation,
+                extendedAttributes: ns.extendedAttributes,
+                fileName: ns.fileName
+            }));
+        }
+        case IDLKind.File: {
+            const file = get(node);
+            return make(createFile(file.entries.map(clone), file.fileName, file.packageClause, {
+                documentation: file.documentation,
+                extendedAttributes: file.extendedAttributes,
+                fileName: file.fileName
+            }));
+        }
+    }
+}
 function escapeIDLKeyword(name) {
     return name + (IDLKeywords.has(name) ? "_" : "");
 }
@@ -4311,15 +4527,17 @@ function printMethod(idl) {
     ];
 }
 function printPackage(idl) {
-    if (!idl.packageClause.length)
+    const effectiveClause = idl.packageClause.filter(it => !!it);
+    if (!effectiveClause.length)
         return [];
     return [
-        `package ${idl.packageClause.join(".")};`
+        `package ${effectiveClause.join(".")};`
     ];
 }
 function printImport(idl) {
+    const effectiveClause = idl.clause.filter(it => !!it);
     return [
-        `import ${idl.clause.join(".")}${idl.name ? " as " : ""}${idl.name};`
+        `import ${effectiveClause.join(".") || "NULL_IMPORT"}${idl.name ? " as " : ""}${idl.name};`
     ];
 }
 function printNamespace(idl) {
@@ -4484,6 +4702,15 @@ const DebugUtils = {
 function isStringEnum(decl) {
     return decl.elements.some(e => e.type === IDLStringType);
 }
+function linearizeNamespaceMembers(entries) {
+    const linearized = [];
+    for (const entry of entries) {
+        linearized.push(entry);
+        if (isNamespace(entry))
+            linearized.push(...linearizeNamespaceMembers(entry.members));
+    }
+    return linearized;
+}
 function extremumOfOrdinals(enumEntry) {
     let low = 0;
     let high = 0;
@@ -4632,8 +4859,20 @@ class ValidationBox {
         });
     }
 }
-class ConfigDescriberLeaf {
+class ConfigDescriberBase {
+    constructor() {
+        this.$ = {
+            mergeStrategy: 'merge'
+        };
+    }
+    onMerge(strategy) {
+        this.$.mergeStrategy = strategy;
+        return this;
+    }
+}
+class ConfigDescriberLeaf extends ConfigDescriberBase {
     constructor(validate, printSchema) {
+        super();
         this.validate = validate;
         this.printSchema = printSchema;
     }
@@ -4843,6 +5082,71 @@ const D = {
             };
         });
     },
+    union(...items) {
+        return new ConfigDescriberLeaf(xs => {
+            for (const item of items) {
+                const r = item.validate(xs);
+                if (r.success()) {
+                    return r;
+                }
+            }
+            return ValidationBox.fail('Not matched');
+        }, () => {
+            return {
+                oneOf: items.map(it => it.printSchema())
+            };
+        });
+    },
+    literal: {
+        string(x) {
+            return new ConfigDescriberLeaf(xs => {
+                if (typeof xs === 'string' && x === xs) {
+                    return ValidationBox.ok(xs);
+                }
+                return ValidationBox.fail('Not matched');
+            }, () => {
+                return {
+                    'const': x
+                };
+            });
+        },
+        number(x) {
+            return new ConfigDescriberLeaf(xs => {
+                if (typeof xs === 'number' && x === xs) {
+                    return ValidationBox.ok(xs);
+                }
+                return ValidationBox.fail('Not matched');
+            }, () => {
+                return {
+                    'const': x
+                };
+            });
+        },
+        boolean(x) {
+            return new ConfigDescriberLeaf(xs => {
+                if (typeof xs === 'boolean' && x === xs) {
+                    return ValidationBox.ok(xs);
+                }
+                return ValidationBox.fail('Not matched');
+            }, () => {
+                return {
+                    'const': x
+                };
+            });
+        },
+        null(x) {
+            return new ConfigDescriberLeaf(xs => {
+                if (typeof xs === 'object' && xs === null) {
+                    return ValidationBox.ok(null);
+                }
+                return ValidationBox.fail('Expected null');
+            }, () => {
+                return {
+                    'const': null
+                };
+            });
+        }
+    },
     ////////////////////////////////////////
     // Utils
     combine(a, b) {
@@ -4908,10 +5212,12 @@ D.object({
     ignoreMaterialized: T.stringArray(),
     builderClasses: T.stringArray(),
     forceMaterialized: T.stringArray(),
-    forceCallback: T.stringArray(),
+    forceCallback: D.map(D.string(), T.stringArray()).onMerge('replace'),
+    forceResource: T.stringArray(),
     forceContext: T.stringArray(),
     moduleName: D.string(),
-    modules: D.map(D.string(), ModuleConfigurationSchema)
+    modules: D.map(D.string(), ModuleConfigurationSchema).onMerge('replace'),
+    globalPackages: T.stringArray()
 });
 const defaultCoreConfiguration = {
     TypePrefix: "",
@@ -4923,10 +5229,12 @@ const defaultCoreConfiguration = {
     ignoreMaterialized: [],
     builderClasses: [],
     forceMaterialized: [],
-    forceCallback: [],
+    forceCallback: new Map(),
+    forceResource: [],
     forceContext: [],
     moduleName: "",
     modules: new Map(),
+    globalPackages: []
 };
 let currentConfig = defaultCoreConfiguration;
 function generatorConfiguration() {
@@ -5073,7 +5381,7 @@ const select = {
     nodes(params) {
         const key = 'entities' + serializeParam(params);
         function go(node) {
-            if (isNamespace$1(node) && (params === null || params === void 0 ? void 0 : params.expandNamespaces)) {
+            if (isNamespace(node) && (params === null || params === void 0 ? void 0 : params.expandNamespaces)) {
                 return node.members.flatMap(go);
             }
             return [node];
@@ -5445,14 +5753,13 @@ class CheckOptionalStatement {
 }
 // maybe rename or move of fix
 class TsEnumEntityStatement {
-    constructor(enumEntity, isExport) {
+    constructor(enumEntity, options) {
         this.enumEntity = enumEntity;
-        this.isExport = isExport;
+        this.options = options;
     }
     write(writer) {
         // writer.print(this.enumEntity.comment)
-        getNamespacesPathFor(this.enumEntity).forEach(it => writer.pushNamespace(it.name));
-        writer.print(`${this.isExport ? "export " : ""}enum ${this.enumEntity.name} {`);
+        writer.print(`${this.options.isExport ? "export " : ""}${this.options.isDeclare ? "declare " : ""}enum ${this.enumEntity.name} {`);
         writer.pushIndent();
         this.enumEntity.elements.forEach((member, index) => {
             // writer.print(member.comment)
@@ -5467,7 +5774,6 @@ class TsEnumEntityStatement {
         });
         writer.popIndent();
         writer.print(`}`);
-        getNamespacesPathFor(this.enumEntity).forEach(it => writer.popNamespace());
     }
     maybeQuoted(value) {
         if (typeof value == "string")
@@ -5508,6 +5814,10 @@ class LambdaExpression {
 ////////////////////////////////////////////////////////////////
 //                         SIGNATURES                         //
 ////////////////////////////////////////////////////////////////
+var ArgumentModifier;
+(function (ArgumentModifier) {
+    ArgumentModifier[ArgumentModifier["OPTIONAL"] = 0] = "OPTIONAL";
+})(ArgumentModifier || (ArgumentModifier = {}));
 var FieldModifier;
 (function (FieldModifier) {
     FieldModifier[FieldModifier["READONLY"] = 0] = "READONLY";
@@ -5561,12 +5871,13 @@ PrintHint.AsConstPointer = new PrintHint('AsConstPointer');
 PrintHint.AsValue = new PrintHint('AsValue');
 PrintHint.AsConstReference = new PrintHint('AsConstReference');
 class MethodSignature {
-    constructor(returnType, args, defaults = undefined, printHints, argNames) {
+    constructor(returnType, args, defaults = undefined, argsModifiers = undefined, printHints, argNames) {
         this.returnType = returnType;
         this.args = args;
         this.defaults = defaults;
         this.printHints = printHints;
         this.argNames = argNames;
+        this.argsModifiers = argsModifiers === null || argsModifiers === void 0 ? void 0 : argsModifiers.map(it => it === undefined ? [] : Array.isArray(it) ? it : [it]);
     }
     argName(index) {
         var _a, _b;
@@ -5576,6 +5887,10 @@ class MethodSignature {
         var _a;
         return (_a = this.defaults) === null || _a === void 0 ? void 0 : _a[index];
     }
+    isArgOptional(index) {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.argsModifiers) === null || _a === void 0 ? void 0 : _a[index]) === null || _b === void 0 ? void 0 : _b.includes(ArgumentModifier.OPTIONAL)) !== null && _c !== void 0 ? _c : false;
+    }
     retHint() {
         var _a;
         return (_a = this.printHints) === null || _a === void 0 ? void 0 : _a[0];
@@ -5589,8 +5904,8 @@ class MethodSignature {
     }
 }
 class NamedMethodSignature extends MethodSignature {
-    constructor(returnType, args = [], argsNames = [], defaults = undefined, printHints) {
-        super(returnType, args, defaults, printHints);
+    constructor(returnType, args = [], argsNames = [], defaults = undefined, argsModifiers = undefined, printHints) {
+        super(returnType, args, defaults, argsModifiers, printHints);
         this.argsNames = argsNames;
     }
     static make(returnType, args) {
@@ -5745,9 +6060,6 @@ class LanguageWriter {
     makeUnionTypeDefaultInitializer() {
         return this.makeRuntimeType(RuntimeType.UNDEFINED);
     }
-    makeRuntimeTypeGetterCall(value) {
-        return this.makeFunctionCall("runtimeType", [this.makeString(value)]);
-    }
     makeArrayResize(array, arrayType, length, deserializer) {
         return new ExpressionStatement(new StringExpression(""));
     }
@@ -5834,8 +6146,8 @@ class LanguageWriter {
     makeIsTypeCall(value, decl) {
         return this.makeString(`is${decl.name}(${value})`);
     }
-    makeEnumEntity(enumEntity, isExport) {
-        return new TsEnumEntityStatement(enumEntity, isExport);
+    makeEnumEntity(enumEntity, options) {
+        return new TsEnumEntityStatement(enumEntity, { isExport: options.isExport, isDeclare: !!options.isDeclare });
     }
     makeFieldModifiersList(modifiers, customFieldFilter) {
         let allowedModifiers = this.supportedFieldModifiers;
@@ -5888,45 +6200,6 @@ class LanguageWriter {
     typeInstanceOf(type, value, members) {
         return this.makeString(`${value} instanceof ${this.getNodeName(type)}`);
     }
-    makeLengthSerializer(serializer, value) {
-        const valueType = "valueType";
-        return this.makeBlock([
-            this.makeAssign(valueType, undefined, this.makeFunctionCall("runtimeType", [this.makeString(value)]), true),
-            this.makeStatement(this.makeMethodCall(serializer, "writeInt8", [this.makeString(valueType)])),
-            this.makeMultiBranchCondition([
-                {
-                    expr: this.makeRuntimeTypeCondition(valueType, true, RuntimeType.NUMBER),
-                    stmt: this.makeStatement(this.makeMethodCall(serializer, "writeFloat32", [this.makeString(`${value} as float32`)]))
-                },
-                {
-                    expr: this.makeRuntimeTypeCondition(valueType, true, RuntimeType.STRING),
-                    stmt: this.makeStatement(this.makeMethodCall(serializer, "writeString", [this.makeString(`${value} as string`)]))
-                },
-                {
-                    expr: this.makeRuntimeTypeCondition(valueType, true, RuntimeType.OBJECT),
-                    stmt: this.makeStatement(this.makeMethodCall(serializer, "writeInt32", [this.makeString(`(${value} as Resource).id as int32`)]))
-                },
-            ]),
-        ], false);
-    }
-    makeLengthDeserializer(deserializer) {
-        const valueType = "valueType";
-        return this.makeBlock([
-            this.makeAssign(valueType, undefined, this.makeMethodCall(deserializer, "readInt8", []), true),
-            this.makeMultiBranchCondition([{
-                    expr: this.makeRuntimeTypeCondition(valueType, true, RuntimeType.NUMBER),
-                    stmt: this.makeReturn(this.makeString(`${deserializer}.readFloat32() as number`))
-                },
-                {
-                    expr: this.makeRuntimeTypeCondition(valueType, true, RuntimeType.STRING),
-                    stmt: this.makeReturn(this.makeMethodCall(deserializer, "readString", []))
-                },
-                {
-                    expr: this.makeRuntimeTypeCondition(valueType, true, RuntimeType.OBJECT),
-                    stmt: this.makeReturn(this.makeString(`({id: ${deserializer}.readInt32(), bundleName: "", moduleName: ""}) as Resource`))
-                }], this.makeReturn(this.makeUndefined())),
-        ], false);
-    }
     stringifyTypeOrEmpty(type) {
         if (type === undefined)
             return "";
@@ -5950,7 +6223,16 @@ class LanguageWriter {
             this.popIndent();
         this.print(`}`);
     }
+    static get isReferenceRelativeToNamespaces() { return this._isReferenceRelativeToNamespaces; }
+    static relativeReferences(isRelative, op) {
+        const prevIsRelative = this.isReferenceRelativeToNamespaces;
+        this._isReferenceRelativeToNamespaces = isRelative;
+        const result = op();
+        this._isReferenceRelativeToNamespaces = prevIsRelative;
+        return result;
+    }
 }
+LanguageWriter._isReferenceRelativeToNamespaces = false;
 
 /*
  * Copyright (c) 2024 Huawei Device Co., Ltd.
@@ -6053,10 +6335,12 @@ function convertType(convertor, type) {
         return convertor.convertUnion(type);
     if (isContainerType(type))
         return convertor.convertContainer(type);
+    if (isImport(type))
+        return convertor.convertImport(type);
     if (isReferenceType(type)) {
         const importAttr = getExtAttribute(type, IDLExtendedAttributes.Import);
         return importAttr
-            ? convertor.convertImport(type, importAttr)
+            ? convertor.convertTypeReferenceAsImport(type, importAttr)
             : convertor.convertTypeReference(type);
     }
     if (isTypeParameterType(type))
@@ -6161,7 +6445,7 @@ class CLikeLanguageWriter extends LanguageWriter {
     writeMethodDeclaration(name, signature, modifiers) {
         this.writeDeclaration(name, signature, modifiers, ";");
     }
-    writeEnum(name, members, op) {
+    writeEnum(name, members, options, op) {
         throw new Error("WriteEnum for C-family languages is not implemented");
     }
     writeMethodImplementation(method, op) {
@@ -6203,15 +6487,15 @@ class CLikeLanguageWriter extends LanguageWriter {
 //                        EXPRESSIONS                         //
 ////////////////////////////////////////////////////////////////
 class CppCastExpression {
-    constructor(convertor, value, type, options) {
+    constructor(convertor, value, node, options) {
         this.convertor = convertor;
         this.value = value;
-        this.type = type;
+        this.node = node;
         this.options = options;
     }
     asString() {
         var _a, _b, _c, _d;
-        if (forceAsNamedNode(this.type).name === "Tag") {
+        if (forceAsNamedNode(this.node).name === "Tag") {
             return `${this.value.asString()} == ${PrimitiveTypeList.UndefinedRuntime} ? ${PrimitiveTypeList.UndefinedTag} : ${PrimitiveTypeList.ObjectTag}`;
         }
         let resultName = '';
@@ -6219,7 +6503,7 @@ class CppCastExpression {
             resultName = this.options.overrideTypeName;
         }
         else {
-            const pureName = this.mapTypeWithReceiver(this.type, (_b = this.options) === null || _b === void 0 ? void 0 : _b.receiver);
+            const pureName = this.mapTypeWithReceiver((_b = this.options) === null || _b === void 0 ? void 0 : _b.receiver);
             const qualifiedName = ((_c = this.options) === null || _c === void 0 ? void 0 : _c.toRef) ? `${pureName}&` : pureName;
             resultName = qualifiedName;
         }
@@ -6227,12 +6511,12 @@ class CppCastExpression {
             ? `reinterpret_cast<${resultName}>(${this.value.asString()})`
             : `static_cast<${resultName}>(${this.value.asString()})`;
     }
-    mapTypeWithReceiver(type, receiver) {
+    mapTypeWithReceiver(receiver) {
         // make deducing type from receiver
         if (receiver !== undefined) {
             return `std::decay<decltype(${receiver})>::type`;
         }
-        return this.convertor.convert(type);
+        return this.convertor.convert(this.node);
     }
 }
 class CppPointerPropertyAccessExpression {
@@ -6492,8 +6776,8 @@ class CppLanguageWriter extends CLikeLanguageWriter {
     makeMapResize(mapTypeName, keyType, valueType, map, size, deserializer) {
         return new CppMapResizeStatement(mapTypeName, keyType, valueType, map, size, deserializer);
     }
-    makeCast(expr, type, options) {
-        return new CppCastExpression(this.typeConvertor, expr, type, options);
+    makeCast(expr, node, options) {
+        return new CppCastExpression(this.typeConvertor, expr, node, options);
     }
     makePointerPropertyAccessExpression(expression, name) {
         return new CppPointerPropertyAccessExpression(expression, name);
@@ -6548,11 +6832,8 @@ class CppLanguageWriter extends CLikeLanguageWriter {
     get supportedFieldModifiers() {
         return [];
     }
-    enumFromOrdinal(value, type) {
-        return this.makeString(`static_cast<${this.typeConvertor.convert(type)}>(` + value.asString() + `)`);
-    }
-    ordinalFromEnum(value, _) {
-        return value;
+    enumFromI32(value, enumEntry) {
+        return this.makeString(`static_cast<${this.typeConvertor.convert(enumEntry)}>(` + value.asString() + `)`);
     }
     makeUnsafeCast(param) {
         return param;
@@ -6572,13 +6853,13 @@ class CppLanguageWriter extends CLikeLanguageWriter {
         }
         return `(${typeName}) (${value.asString()})`;
     }
-    makeEnumCast(enumEntry, value) {
-        return `static_cast<${this.typeConvertor.convert(createReferenceType(enumEntry))}>(${value})`;
+    i32FromEnum(value, enumEntry) {
+        return this.makeString(`static_cast<${this.typeConvertor.convert(createReferenceType(enumEntry))}>(${value.asString()})`);
     }
     escapeKeyword(name) {
         return cppKeywords.has(name) ? name + "_" : name;
     }
-    makeEnumEntity(enumEntity, isExport) {
+    makeEnumEntity(enumEntity, options) {
         return new CppEnumEntityStatement(enumEntity);
     }
     decayTypeName(typeName) {
@@ -6639,43 +6920,12 @@ class CppLanguageWriter extends CLikeLanguageWriter {
             IDLSerializerBuffer,
             IDLU32Type,
             createReferenceType("CallbackResourceHolder")
-        ], ["data", "dataLength", "resourceHolder"], [undefined, `0`, `nullptr`], [undefined, undefined, undefined, PrintHint.AsPointer]);
+        ], ["data", "dataLength", "resourceHolder"], [undefined, `0`, `nullptr`], undefined, [undefined, undefined, undefined, PrintHint.AsPointer]);
         const ownedDataCtor = new NamedMethodSignature(IDLVoidType, [
             createReferenceType("CallbackResourceHolder")
-        ], ["resourceHolder"], [`nullptr`], [undefined, PrintHint.AsPointer]);
+        ], ["resourceHolder"], [`nullptr`], undefined, [undefined, PrintHint.AsPointer]);
         return [ownedDataCtor, fromBufferCtor];
     }
-    makeLengthSerializer(serializer, value) {
-        return undefined;
-    }
-    makeLengthDeserializer(deserializer) {
-        return undefined;
-    }
-}
-
-/*
- * 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.
- */
-function isStringEnumType(type, resolver) {
-    const enumNode = toEnum(type, resolver);
-    return enumNode ? isStringEnum(enumNode) : false;
-}
-function toEnum(type, resolver) {
-    if (!isReferenceType(type))
-        return undefined;
-    const resolved = resolver.resolveTypeReference(type);
-    return resolved && isEnum$1(resolved) ? resolved : undefined;
 }
 
 /*
@@ -6807,14 +7057,14 @@ class TSLanguageWriter extends LanguageWriter {
         return new TSLanguageWriter(new IndentedPrinter(), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.language);
     }
     getNodeName(type) {
-        // just stub.
-        // language writers and name convertors are subject to rework for namespaces
-        const row = this.typeConvertor.convert(type);
-        const nsPrefix = this.namespaceStack.join('.') + '.';
-        if (row.startsWith(nsPrefix)) {
-            return row.substring(nsPrefix.length);
+        // another stub. Bad one.
+        // I hope that I will rewrite LWs soon
+        if (isType(type) && isReferenceType(type)) {
+            if (type.name.startsWith('%TEXT%:')) {
+                return type.name.substring(7);
+            }
         }
-        return row;
+        return this.typeConvertor.convert(type);
     }
     writeClass(name, op, superClass, interfaces, generics, isDeclared, isAbstract) {
         let extendsClause = superClass ? ` extends ${superClass}` : '';
@@ -6856,8 +7106,8 @@ class TSLanguageWriter extends LanguageWriter {
         const returnType = this.getNodeName(signature.returnType);
         return `export function ${name}(${args.join(", ")}): ${returnType}`;
     }
-    writeEnum(name, members) {
-        this.printer.print(`export enum ${name} {`);
+    writeEnum(name, members, options) {
+        this.printer.print(`${options.isExport ? "export " : ""}${options.isDeclare ? "declare " : ""}enum ${name} {`);
         this.printer.pushIndent();
         for (const [index, member] of members.entries()) {
             let value;
@@ -6945,7 +7195,6 @@ class TSLanguageWriter extends LanguageWriter {
         this.print(`export const ${constName}: ${this.getNodeName(constType)}${constVal ? ' = ' + constVal : ''}`);
     }
     writeDeclaration(name, signature, needReturn, needBracket, modifiers, generics) {
-        var _a;
         let prefix = !modifiers ? undefined : this.supportedModifiers
             .filter(it => modifiers.includes(it))
             .map(it => this.mapMethodModifier(it)).join(" ");
@@ -6961,19 +7210,8 @@ class TSLanguageWriter extends LanguageWriter {
         }
         prefix = prefix ? prefix.trim() + " " : "";
         const typeParams = (generics === null || generics === void 0 ? void 0 : generics.length) ? `<${generics.join(", ")}>` : "";
-        // FIXME:
-        const isSetter = modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(MethodModifier.SETTER);
-        const canBeOptional = [];
-        for (let i = signature.args.length - 1; i >= 0; --i) {
-            const prevCanBeOptional = (_a = canBeOptional.at(-1)) !== null && _a !== void 0 ? _a : true;
-            const curr = signature.args[i];
-            const result = prevCanBeOptional && (isOptionalType(curr) || signature.argDefault(i) !== undefined);
-            canBeOptional.push(result);
-        }
-        canBeOptional.reverse();
-        const isOptional = signature.args.map((it, i) => isOptionalType(it) && canBeOptional[i] && !isSetter);
-        const normalizedArgs = signature.args.map((it, i) => isOptionalType(it) && isOptional[i] ? maybeUnwrapOptionalType(it) : it);
-        this.printer.print(`${prefix}${name}${typeParams}(${normalizedArgs.map((it, index) => `${this.escapeKeyword(signature.argName(index))}${isOptional[index] ? "?" : ""}: ${this.getNodeName(it)}${signature.argDefault(index) ? ' = ' + signature.argDefault(index) : ""}`).join(", ")})${needReturn ? ": " + this.getNodeName(signature.returnType) : ""}${needBracket ? " {" : ""}`);
+        const normalizedArgs = signature.args.map((it, i) => isOptionalType(it) && signature.isArgOptional(i) ? maybeUnwrapOptionalType(it) : it);
+        this.printer.print(`${prefix}${name}${typeParams}(${normalizedArgs.map((it, index) => `${this.escapeKeyword(signature.argName(index))}${signature.isArgOptional(index) ? "?" : ``}: ${this.getNodeName(it)}${signature.argDefault(index) ? ' = ' + signature.argDefault(index) : ""}`).join(", ")})${needReturn ? ": " + this.getNodeName(signature.returnType) : ""}${needBracket ? " {" : ""}`);
     }
     makeNull() {
         return new StringExpression("undefined");
@@ -7005,9 +7243,9 @@ class TSLanguageWriter extends LanguageWriter {
     writePrintLog(message) {
         this.print(`console.log("${message}")`);
     }
-    makeCast(value, type, options) {
+    makeCast(value, node, options) {
         var _a;
-        return new TSCastExpression(value, this.getNodeName(/* FIXME: */ maybeUnwrapOptionalType(type)), (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
+        return new TSCastExpression(value, this.getNodeName(node), (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
     }
     typeInstanceOf(type, value, members) {
         if (isInterface$1(type)) {
@@ -7070,27 +7308,19 @@ class TSLanguageWriter extends LanguageWriter {
     get supportedFieldModifiers() {
         return [FieldModifier.PUBLIC, FieldModifier.PRIVATE, FieldModifier.PROTECTED, FieldModifier.READONLY, FieldModifier.STATIC];
     }
-    enumFromOrdinal(value, enumEntry) {
-        const enumName = forceAsNamedNode(enumEntry).name;
+    enumFromI32(value, enumEntry) {
+        const enumName = enumEntry.name;
         const ordinal = value.asString();
-        return isStringEnumType(enumEntry, this.resolver)
+        return isStringEnum(enumEntry)
             ? this.makeString(`Object.values(${enumName})[${ordinal}]`)
-            : this.makeString(`${ordinal}`);
+            : this.makeString(ordinal);
     }
-    ordinalFromEnum(value, enumEntry) {
-        const enumName = forceAsNamedNode(enumEntry).name;
-        const decl = isReferenceType(enumEntry) ? this.resolver.resolveTypeReference(enumEntry) : undefined;
-        if (decl && isEnum$1(decl) && isStringEnum(decl)) {
+    i32FromEnum(value, enumEntry) {
+        const enumName = this.getNodeName(enumEntry);
+        if (isEnum$1(enumEntry) && isStringEnum(enumEntry)) {
             return this.makeString(`Object.values(${enumName}).indexOf(${value.asString()})`);
         }
-        return value;
-    }
-    makeEnumCast(enumEntry, param) {
-        // Take the ordinal value if Enum is a string, and valueOf when it is an integer
-        // Enum.valueOf() - compatible with ArkTS/TS
-        return isStringEnum(enumEntry)
-            ? this.ordinalFromEnum(this.makeString(param), createReferenceType(enumEntry)).asString()
-            : `${param}.valueOf()`;
+        return this.makeString(`${value.asString()}.valueOf()`);
     }
     castToBoolean(value) { return `+${value}`; }
     makeCallIsObject(value) {
@@ -7108,7 +7338,7 @@ class TSLanguageWriter extends LanguageWriter {
             throwException(`The type reference ${decl === null || decl === void 0 ? void 0 : decl.name} must be Enum`);
         }
         const ordinal = isStringEnum(decl)
-            ? this.ordinalFromEnum(this.makeCast(this.makeString(this.getObjectAccessor(convertor, value)), convertor.idlType), createReferenceType(this.getNodeName(convertor.nativeType())))
+            ? this.i32FromEnum(this.makeCast(this.makeString(this.getObjectAccessor(convertor, value)), convertor.idlType), decl)
             : this.makeUnionVariantCast(this.getObjectAccessor(convertor, value), this.getNodeName(IDLI32Type), convertor, index);
         const { low, high } = extremumOfOrdinals(decl);
         return this.discriminatorFromExpressions(value, convertor.runtimeTypes[0], [
@@ -7140,6 +7370,7 @@ var 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) {
@@ -7190,7 +7421,7 @@ function isInCurrentModule(nodeOrPackage) {
             next.forEach(node => {
                 if (!isInCurrentModule(node))
                     return;
-                if (isNamespace$1(node)) {
+                if (isNamespace(node)) {
                     queue.push(node.members);
                 }
                 if (isConstant$1(node)) {
@@ -7208,6 +7439,17 @@ function isInCurrentModule(nodeOrPackage) {
     }))
 });
 
+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,
@@ -7325,381 +7567,467 @@ function toString(node) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+function getTokens(node) {
+    return node.tokens;
+}
 const syntheticTypes = new Map();
 function addSyntheticType(name, type) {
-    if (syntheticTypes.has(name))
-        warn(`duplicate synthetic type name "${name}"`); ///throw?
+    if (syntheticTypes.has(name)) {
+        warn(`duplicate synthetic type name "${name}"`);
+    }
     syntheticTypes.set(name, type);
 } // check
-function toIDLNode(file, node) {
-    return toIDLNodeForward(file, node);
-}
-function toIDLNodeForward(file, node) {
-    if (isEnum(node)) {
-        return toIDLEnum(file, node);
-    }
-    if (isImport(node)) {
-        return toIDLImport(node);
+class IDLDeserializer {
+    constructor(info) {
+        this.info = info;
+        this.namespacePathNames = [];
+        this.currentPackage = [];
+        this.genericsScopes = [];
+    }
+    ///
+    withInfo(from, result) {
+        this.info.set(result, getTokens(from));
+        return result;
     }
-    if (isClass(node)) {
-        return toIDLInterface(file, node);
+    setPackage(pkg) {
+        this.currentPackage = pkg;
     }
-    if (isInterface(node)) {
-        return toIDLInterface(file, node);
+    ///
+    sanitizeTypeParameter(param) {
+        const extendsIdx = param.indexOf('extends');
+        if (extendsIdx !== -1) {
+            return param.substring(0, extendsIdx).trim();
+        }
+        const eqIdx = param.indexOf('=');
+        if (eqIdx !== -1) {
+            return param.substring(0, eqIdx).trim();
+        }
+        return param;
     }
-    if (isCallback(node)) {
-        return toIDLCallback(file, node);
+    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)));
     }
-    if (isTypedef(node)) {
-        return toIDLTypedef(file, node);
+    ///
+    toIDLNode(file, node) {
+        return this.toIDLNodeForward(file, node);
     }
-    if (isDictionary(node)) {
-        return toIDLDictionary(file, node);
+    toIDLNodeForward(file, node) {
+        if (isEnum(node)) {
+            return this.toIDLEnum(file, node);
+        }
+        if (this.isImport(node)) {
+            return this.toIDLImport(node);
+        }
+        if (isClass(node)) {
+            return this.toIDLInterface(file, node);
+        }
+        if (isInterface(node)) {
+            return this.toIDLInterface(file, node);
+        }
+        if (isCallback(node)) {
+            return this.toIDLCallback(file, node);
+        }
+        if (isTypedef(node)) {
+            return this.toIDLTypedef(file, node);
+        }
+        if (isDictionary(node)) {
+            return this.toIDLDictionary(file, node);
+        }
+        if (this.isNamespace(node)) {
+            return this.toIDLNamespace(file, node);
+        }
+        if (this.isVersion(node)) {
+            return this.toIDLVersion(file, node);
+        }
+        if (isAttribute(node)) {
+            return this.toIDLProperty(file, node);
+        }
+        if (isOperation(node)) {
+            return this.toIDLMethod(file, node, true);
+        }
+        if (isConstant(node)) {
+            return this.toIDLConstant(file, node);
+        }
+        throw new Error(`unexpected node type: ${toString(node)}`);
     }
-    if (isNamespace(node)) {
-        return toIDLNamespace(file, node);
+    toIDLImport(node) {
+        // console.log(node)
+        return this.withInfo(node, createImport(node.clause.split("."), node.alias || undefined));
     }
-    if (isVersion(node)) {
-        return toIDLVersion(file, node);
+    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;
     }
-    if (isAttribute(node)) {
-        return toIDLProperty(file, node);
+    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)
+                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];
+        })(), node.members
+            .filter(isConstructor)
+            .map(it => this.toIDLConstructor(file, it)), [], node.members
+            .filter(isAttribute)
+            .map(it => this.toIDLProperty(file, it)), node.members
+            .filter(isOperation)
+            .filter(it => !this.isCallable(it))
+            .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(","), {
+            fileName: file,
+            documentation: this.makeDocs(node),
+            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+        });
+        this.genericsScopes.pop();
+        this.info.set(result, getTokens(node));
+        if (node.extAttrs.find(it => it.name === "Synthetic")) {
+            const fqName = this.currentPackage.concat(this.namespacePathNames).concat([node.name]).join('.');
+            addSyntheticType(fqName, result);
+        }
+        return result;
     }
-    if (isOperation(node)) {
-        return toIDLMethod(file, node);
+    toIDLType(file, type, extAttrs) {
+        var _a;
+        if (typeof type === "string") {
+            // is it IDLStringType?
+            const refType = createReferenceType(type);
+            refType.fileName = file;
+            refType.typeArguments = this.extractTypeArguments(file, extAttrs, IDLExtendedAttributes.TypeArguments);
+            return refType;
+        }
+        if (type.nullable) {
+            return this.withInfo(type, createOptionalType(this.toIDLType(file, Object.assign(Object.assign({}, type), { nullable: false }), extAttrs)));
+        }
+        if (isUnionTypeDescription(type)) {
+            let types = type.idlType
+                .map(it => this.toIDLType(file, it, undefined))
+                .filter(isDefined);
+            if (types.includes(IDLUndefinedType)) {
+                types = types.filter(it => it !== IDLUndefinedType);
+                return this.withInfo(type, createOptionalType(collapseTypes(types)));
+            }
+            const name = generateSyntheticUnionName(types);
+            return this.withInfo(type, createUnionType(types, name));
+        }
+        if (isSingleTypeDescription(type)) {
+            // must match with primitive types in idl.ts
+            switch (type.idlType) {
+                case IDLPointerType.name: return IDLPointerType;
+                case IDLVoidType.name: return IDLVoidType;
+                case IDLBooleanType.name: return IDLBooleanType;
+                case IDLObjectType.name: return IDLObjectType;
+                case IDLI8Type.name: return IDLI8Type;
+                case IDLU8Type.name: return IDLU8Type;
+                case IDLI16Type.name: return IDLI16Type;
+                case IDLU16Type.name: return IDLU16Type;
+                case IDLI32Type.name: return IDLI32Type;
+                case IDLU32Type.name: return IDLU32Type;
+                case IDLI64Type.name: return IDLI64Type;
+                case IDLU64Type.name: return IDLU64Type;
+                case IDLF32Type.name: return IDLF32Type;
+                case IDLF64Type.name: return IDLF64Type;
+                case IDLBigintType.name: return IDLBigintType;
+                case IDLNumberType.name: return IDLNumberType;
+                case IDLStringType.name: return IDLStringType;
+                case IDLAnyType.name: return IDLAnyType;
+                case IDLUndefinedType.name: return IDLUndefinedType;
+                case IDLUnknownType.name: return IDLUnknownType;
+                case IDLObjectType.name: return IDLObjectType;
+                case IDLThisType.name: return IDLThisType;
+                case IDLDate.name: return IDLDate;
+                case IDLBufferType.name: return IDLBufferType;
+                case IDLSerializerBuffer.name: return IDLSerializerBuffer;
+            }
+            const combinedExtAttrs = ((_a = type.extAttrs) !== null && _a !== void 0 ? _a : []).concat(extAttrs !== null && extAttrs !== void 0 ? extAttrs : []);
+            let idlRefType;
+            if (this.genericsScopes.some(it => it.has(type.idlType))) {
+                idlRefType = createTypeParameterReference(type.idlType);
+            }
+            else {
+                const ref = createReferenceType(type.idlType);
+                ref.typeArguments = this.extractTypeArguments(file, combinedExtAttrs, IDLExtendedAttributes.TypeArguments);
+                idlRefType = ref;
+            }
+            idlRefType.fileName = file;
+            idlRefType.extendedAttributes = this.toExtendedAttributes(combinedExtAttrs);
+            return this.withInfo(type, idlRefType);
+        }
+        if (isSequenceTypeDescription(type) || isPromiseTypeDescription(type) || isRecordTypeDescription(type)) {
+            return this.withInfo(type, createContainerType(type.generic, type.idlType.map(it => this.toIDLType(file, it, undefined))));
+        }
+        if (isUnspecifiedGenericTypeDescription(type)) {
+            return this.withInfo(type, createUnspecifiedGenericType(type.generic, type.idlType.map(it => this.toIDLType(file, it, undefined))));
+        }
+        throw new Error(`unexpected type: ${toString(type)}`);
     }
-    if (isConstant(node)) {
-        return toIDLConstant(file, node);
+    toIDLCallable(file, node) {
+        var _a, _b;
+        if (!node.idlType) {
+            throw new Error(`method with no type ${toString(node)}`);
+        }
+        const generics = this.extractGenerics(node.extAttrs);
+        this.genericsScopes.push(generics);
+        const returnType = this.toIDLType(file, node.idlType, node.extAttrs);
+        if (isReferenceType(returnType)) {
+            const returnTypeArgs = this.extractTypeArguments(file, node.extAttrs, IDLExtendedAttributes.TypeArguments);
+            returnType.typeArguments = returnTypeArgs;
+        }
+        const result = this.withInfo(node, createCallable((_a = node.name) !== null && _a !== void 0 ? _a : "", node.arguments.map(it => this.toIDLParameter(file, it)), returnType, {
+            isStatic: node.special === "static",
+            isAsync: node.async,
+        }, {
+            documentation: this.makeDocs(node),
+            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+        }, (_b = this.findExtendedAttribute(node.extAttrs, IDLExtendedAttributes.TypeParameters)) === null || _b === void 0 ? void 0 : _b.split(",")));
+        this.genericsScopes.pop();
+        return result;
     }
-    throw new Error(`unexpected node type: ${toString(node)}`);
-}
-function isNamespace(node) {
-    return node.type === 'namespace';
-}
-function isVersion(node) {
-    return node.type === 'version';
-}
-function isPackage(node) {
-    return node.type === 'package';
-}
-function isImport(node) {
-    return node.type === 'import';
-}
-function isCallable(node) {
-    return node.extAttrs.some(it => it.name == "Invoke");
-}
-function toIDLImport(node) {
-    // console.log(node)
-    return createImport(node.clause.split("."), node.alias || undefined);
-}
-function 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;
-}
-function toIDLInterface(file, node) {
-    var _a;
-    const result = createInterface(node.name, interfaceSubkind(node), (() => {
+    toIDLMethod(file, node, isFree = false) {
         var _a, _b;
-        if (!node.inheritance)
-            return [];
-        const parentTypeArgs = 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 = toExtendedAttributes(node.inheritanceExtAttrs)) === null || _b === void 0 ? void 0 : _b.filter(it => it.name !== IDLExtendedAttributes.TypeArguments);
-        return [parentType];
-    })(), node.members
-        .filter(isConstructor)
-        .map(it => toIDLConstructor(file, it)), [], node.members
-        .filter(isAttribute)
-        .map(it => toIDLProperty(file, it)), node.members
-        .filter(isOperation)
-        .filter(it => !isCallable(it))
-        .map(it => toIDLMethod(file, it)), node.members
-        .filter(isOperation)
-        .filter(it => isCallable(it))
-        .map(it => toIDLCallable(file, it)), (_a = findExtendedAttribute(node.extAttrs, IDLExtendedAttributes.TypeParameters)) === null || _a === void 0 ? void 0 : _a.split(","), {
-        fileName: file,
-        documentation: makeDocs(node),
-        extendedAttributes: toExtendedAttributes(node.extAttrs),
-    });
-    if (node.extAttrs.find(it => it.name === "Synthetic"))
-        addSyntheticType(node.name, result);
-    return result;
-}
-function 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 = 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 => toIDLType(file, it));
-}
-function toIDLType(file, type, extAttrs) {
-    var _a;
-    if (typeof type === "string") {
-        // is it IDLStringType?
-        const refType = createReferenceType(type);
-        refType.fileName = file;
-        refType.typeArguments = extractTypeArguments(file, extAttrs, IDLExtendedAttributes.TypeArguments);
-        return refType;
-    }
-    if (type.nullable) {
-        return createOptionalType(toIDLType(file, Object.assign(Object.assign({}, type), { nullable: false }), extAttrs));
-    }
-    if (isUnionTypeDescription(type)) {
-        const types = type.idlType
-            .map(it => toIDLType(file, it))
-            .filter(isDefined);
-        const name = generateSyntheticUnionName(types);
-        return createUnionType(types, name);
-    }
-    if (isSingleTypeDescription(type)) {
-        switch (type.idlType) {
-            case IDLUnknownType.name: return IDLUnknownType;
-            case IDLObjectType.name: return IDLObjectType;
-            case IDLAnyType.name: return IDLAnyType;
-            case IDLBooleanType.name: return IDLBooleanType;
-            case IDLNumberType.name: return IDLNumberType;
-            case IDLStringType.name: return IDLStringType;
-            case IDLUndefinedType.name: return IDLUndefinedType;
-            case IDLVoidType.name: return IDLVoidType;
-            case IDLI8Type.name: return IDLI8Type;
-            case IDLU8Type.name: return IDLU8Type;
-            case IDLI16Type.name: return IDLI16Type;
-            case IDLU16Type.name: return IDLU16Type;
-            case IDLI32Type.name: return IDLI32Type;
-            case IDLU32Type.name: return IDLU32Type;
-            case IDLI64Type.name: return IDLI64Type;
-            case IDLU64Type.name: return IDLU64Type;
-            case IDLF32Type.name: return IDLF32Type;
-            case IDLF64Type.name: return IDLF64Type;
-            case IDLPointerType.name: return IDLPointerType;
-            case IDLBufferType.name: return IDLBufferType;
-        }
-        const combinedExtAttrs = ((_a = type.extAttrs) !== null && _a !== void 0 ? _a : []).concat(extAttrs !== null && extAttrs !== void 0 ? extAttrs : []);
-        const idlRefType = createReferenceType(type.idlType);
-        idlRefType.fileName = file;
-        idlRefType.typeArguments = extractTypeArguments(file, combinedExtAttrs, IDLExtendedAttributes.TypeArguments);
-        idlRefType.extendedAttributes = toExtendedAttributes(combinedExtAttrs);
-        return idlRefType;
-    }
-    if (isSequenceTypeDescription(type) || isPromiseTypeDescription(type) || isRecordTypeDescription(type)) {
-        return createContainerType(type.generic, type.idlType.map(it => toIDLType(file, it)));
-    }
-    if (isUnspecifiedGenericTypeDescription(type)) {
-        return createUnspecifiedGenericType(type.generic, type.idlType.map(it => toIDLType(file, it)));
-    }
-    throw new Error(`unexpected type: ${toString(type)}`);
-}
-function toIDLCallable(file, node) {
-    var _a, _b;
-    if (!node.idlType) {
-        throw new Error(`method with no type ${toString(node)}`);
+        if (!node.idlType) {
+            throw new Error(`method with no type ${toString(node)}`);
+        }
+        const generics = this.extractGenerics(node.extAttrs);
+        this.genericsScopes.push(generics);
+        const returnType = this.toIDLType(file, node.idlType, node.extAttrs);
+        if (isReferenceType(returnType))
+            returnType.typeArguments = this.extractTypeArguments(file, node.extAttrs, IDLExtendedAttributes.TypeArguments);
+        const result = this.withInfo(node, createMethod((_a = node.name) !== null && _a !== void 0 ? _a : "", node.arguments.map(it => this.toIDLParameter(file, it !== null && it !== void 0 ? it : new Map())), returnType, {
+            isStatic: node.special === "static",
+            isAsync: node.async,
+            isOptional: isOptional(node),
+            isFree
+        }, {
+            documentation: this.makeDocs(node),
+            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+        }, (_b = this.findExtendedAttribute(node.extAttrs, IDLExtendedAttributes.TypeParameters)) === null || _b === void 0 ? void 0 : _b.split(",")));
+        this.genericsScopes.pop();
+        return result;
     }
-    const returnType = toIDLType(file, node.idlType, node.extAttrs);
-    if (isReferenceType(returnType)) {
-        const returnTypeArgs = extractTypeArguments(file, node.extAttrs, IDLExtendedAttributes.TypeArguments);
-        returnType.typeArguments = returnTypeArgs;
+    toIDLConstructor(file, node) {
+        return this.withInfo(node, createConstructor(node.arguments.map(it => this.toIDLParameter(file, it)), undefined, {
+            documentation: this.makeDocs(node),
+        }));
     }
-    return createCallable((_a = node.name) !== null && _a !== void 0 ? _a : "", node.arguments.map(it => toIDLParameter(file, it)), returnType, {
-        isStatic: node.special === "static",
-        isAsync: node.async,
-    }, {
-        documentation: makeDocs(node),
-        extendedAttributes: toExtendedAttributes(node.extAttrs),
-    }, (_b = findExtendedAttribute(node.extAttrs, IDLExtendedAttributes.TypeParameters)) === null || _b === void 0 ? void 0 : _b.split(","));
-}
-function toIDLMethod(file, node) {
-    var _a, _b;
-    if (!node.idlType) {
-        throw new Error(`method with no type ${toString(node)}`);
-    }
-    const returnType = toIDLType(file, node.idlType, node.extAttrs);
-    if (isReferenceType(returnType))
-        returnType.typeArguments = extractTypeArguments(file, node.extAttrs, IDLExtendedAttributes.TypeArguments);
-    return createMethod((_a = node.name) !== null && _a !== void 0 ? _a : "", node.arguments.map(it => toIDLParameter(file, it)), returnType, {
-        isStatic: node.special === "static",
-        isAsync: node.async,
-        isOptional: isOptional(node),
-        isFree: false, // TODO: namespace-related-to-rework
-    }, {
-        documentation: makeDocs(node),
-        extendedAttributes: toExtendedAttributes(node.extAttrs),
-    }, (_b = findExtendedAttribute(node.extAttrs, IDLExtendedAttributes.TypeParameters)) === null || _b === void 0 ? void 0 : _b.split(","));
-}
-function toIDLConstructor(file, node) {
-    return createConstructor(node.arguments.map(it => toIDLParameter(file, it)), undefined, {
-        documentation: makeDocs(node),
-    });
-}
-function toIDLParameter(file, node) {
-    return createParameter(node.name, toIDLType(file, node.idlType, node.extAttrs), node.optional, node.variadic, {
-        fileName: file,
-    });
-}
-function toIDLCallback(file, node) {
-    const result = createCallback(node.name, node.arguments.map(it => toIDLParameter(file, it)), toIDLType(file, node.idlType), {
-        fileName: file,
-        extendedAttributes: toExtendedAttributes(node.extAttrs),
-        documentation: makeDocs(node),
-    });
-    if (node.extAttrs.find(it => it.name === "Synthetic"))
-        addSyntheticType(node.name, result);
-    return result;
-}
-function toIDLTypedef(file, node) {
-    var _a;
-    return createTypedef(node.name, toIDLType(file, node.idlType), (_a = findExtendedAttribute(node.extAttrs, IDLExtendedAttributes.TypeParameters)) === null || _a === void 0 ? void 0 : _a.split(","), {
-        extendedAttributes: toExtendedAttributes(node.extAttrs),
-        documentation: makeDocs(node),
-        fileName: file,
-    });
-}
-function toIDLConstant(file, node) {
-    return createConstant(node.name, toIDLType(file, node.idlType), constantValue(node));
-}
-function constantValue(node) {
-    switch (node.value.type) {
-        case "string":
-            return `"${node.value.value}"`;
-        case "number":
-            return node.value.value;
-        case "boolean":
-            return node.value.value.toString();
-        case "null":
-            return "null";
-        case "Infinity":
-            return "Infinity";
-        case "NaN":
-            return "NaN";
-        case "sequence":
-            return `[${node.value.value.join(',')}]`;
-        case "dictionary":
-            return `new Map()`;
-        default:
-            return "undefined";
+    toIDLParameter(file, node) {
+        return this.withInfo(node, createParameter(node.name, this.toIDLType(file, node.idlType, node.extAttrs), node.optional, node.variadic, {
+            fileName: file,
+        }));
     }
-}
-function toIDLDictionary(file, node) {
-    const result = createEnum(node.name, [], {
-        documentation: makeDocs(node),
-        extendedAttributes: toExtendedAttributes(node.extAttrs),
-        fileName: file,
-    });
-    result.elements = node.members.map(it => toIDLEnumMember(file, it, result));
-    return result;
-}
-function toIDLNamespace(file, node) {
-    const namespace = createNamespace(node.name, toExtendedAttributes(node.extAttrs), file);
-    namespace.members = node.members.map(it => toIDLNodeForward(file, it));
-    return namespace;
-}
-function toIDLVersion(file, node) {
-    return createVersion(node.value, toExtendedAttributes(node.extAttrs), file);
-}
-function toIDLProperty(file, node) {
-    return createProperty(node.name, toIDLType(file, node.idlType), node.readonly, node.special === "static", isOptional(node), {
-        documentation: makeDocs(node),
-        fileName: file,
-        extendedAttributes: toExtendedAttributes(node.extAttrs)
-    });
-}
-function unescapeString(value) {
-    if (!value.length || value[0] !== '"')
-        return value;
-    value = value.slice(1, -1);
-    value = value.replace(/\\((['"\\bfnrtv])|([0-7]{1-3})|x([0-9a-fA-F]{2})|u([0-9a-fA-F]{4}))/g, (_, all, c, oct, h2, u4) => {
-        if (c !== undefined) {
-            switch (c) {
-                case "'": return "'";
-                case '"': return '"';
-                case "\\": return "\\";
-                case "b": return "\b";
-                case "f": return "\f";
-                case "n": return "\n";
-                case "r": return "\r";
-                case "t": return "\t";
-                case "v": return "\v";
-            }
+    toIDLCallback(file, node) {
+        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),
+        });
+        if (node.extAttrs.find(it => it.name === "Synthetic")) {
+            const fqName = this.currentPackage.concat(this.namespacePathNames).concat([node.name]).join('.');
+            addSyntheticType(fqName, result);
         }
-        else if (oct !== undefined) {
-            return String.fromCharCode(parseInt(oct, 8));
+        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(","), {
+            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+            documentation: this.makeDocs(node),
+            fileName: file,
+        }));
+        this.genericsScopes.pop();
+        return result;
+    }
+    toIDLConstant(file, node) {
+        return this.withInfo(node, createConstant(node.name, this.toIDLType(file, node.idlType, undefined), this.constantValue(node)));
+    }
+    toIDLDictionary(file, node) {
+        const result = createEnum(node.name, [], {
+            documentation: this.makeDocs(node),
+            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+            fileName: file,
+        });
+        result.elements = node.members.map(it => this.toIDLEnumMember(file, it, result));
+        return this.withInfo(node, result);
+    }
+    toIDLNamespace(file, node) {
+        const namespace = createNamespace(node.name, [], {
+            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+            fileName: file
+        });
+        this.namespacePathNames.push(node.name);
+        namespace.members = node.members.map(it => this.toIDLNodeForward(file, it));
+        this.namespacePathNames.pop();
+        return this.withInfo(node, namespace);
+    }
+    toIDLVersion(file, node) {
+        return this.withInfo(node, createVersion(node.value, {
+            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+            fileName: file
+        }));
+    }
+    toIDLProperty(file, node) {
+        return this.withInfo(node, createProperty(node.name, this.toIDLType(file, node.idlType, undefined), node.readonly, node.special === "static", isOptional(node), {
+            documentation: this.makeDocs(node),
+            fileName: file,
+            extendedAttributes: this.toExtendedAttributes(node.extAttrs)
+        }));
+    }
+    toIDLEnumMember(file, node, parent) {
+        var _a, _b, _c;
+        let initializer = undefined;
+        if (((_a = node.default) === null || _a === void 0 ? void 0 : _a.type) == "string") {
+            initializer = this.unescapeString(node.default.value);
         }
-        else if (h2 !== undefined) {
-            return String.fromCharCode(parseInt(h2, 16));
+        else if (((_b = node.default) === null || _b === void 0 ? void 0 : _b.type) == "number") {
+            initializer = +((_c = node.default) === null || _c === void 0 ? void 0 : _c.value);
         }
-        else if (u4 !== undefined) {
-            return String.fromCharCode(parseInt(u4, 16));
+        else if (node.default == null) {
+            initializer = undefined;
         }
-        throw new Error(`unknown escape sequence: ${_}`);
-    });
-    return value;
-}
-function toIDLEnumMember(file, node, parent) {
-    var _a, _b, _c;
-    let initializer = undefined;
-    if (((_a = node.default) === null || _a === void 0 ? void 0 : _a.type) == "string") {
-        initializer = unescapeString(node.default.value);
+        else {
+            throw new Error(`Not representable enum initializer: ${node.default}`);
+        }
+        return this.withInfo(node, createEnumMember(node.name, parent, this.toIDLType(file, node.idlType, undefined), initializer, {
+            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+        }));
     }
-    else if (((_b = node.default) === null || _b === void 0 ? void 0 : _b.type) == "number") {
-        initializer = +((_c = node.default) === null || _c === void 0 ? void 0 : _c.value);
+    toExtendedAttributes(extAttrs) {
+        return extAttrs.map(it => {
+            return this.withInfo(it, { name: it.name, value: this.toExtendedAttributeValue(it) });
+        });
     }
-    else if (node.default == null) {
-        initializer = undefined;
+    toExtendedAttributeValue(attr) {
+        var _a, _b;
+        // TODO: be smarter about RHS.
+        if (((_a = attr.rhs) === null || _a === void 0 ? void 0 : _a.value) instanceof Array)
+            return attr.rhs.value.map(v => v.value).join(",");
+        if (typeof ((_b = attr.rhs) === null || _b === void 0 ? void 0 : _b.value) === 'string')
+            return this.unescapeString(attr.rhs.value);
+        return;
     }
-    else {
-        throw new Error(`Not representable enum initializer: ${node.default}`);
+    toIDLEnum(file, node) {
+        const result = createEnum(node.name, [], {
+            fileName: file,
+            documentation: this.makeDocs(node),
+            extendedAttributes: this.toExtendedAttributes(node.extAttrs),
+        });
+        result.elements = node.values.map((it) => createEnumMember(it.value, result, IDLNumberType, undefined));
+        return this.withInfo(node, result);
     }
-    return createEnumMember(node.name, parent, toIDLType(file, node.idlType), initializer, {
-        extendedAttributes: toExtendedAttributes(node.extAttrs),
-    });
-}
-function toExtendedAttributes(extAttrs) {
-    return extAttrs.map(it => {
-        return { name: it.name, value: toExtendedAttributeValue(it) };
-    });
-}
-function toExtendedAttributeValue(attr) {
-    var _a, _b;
-    // TODO: be smarter about RHS.
-    if (((_a = attr.rhs) === null || _a === void 0 ? void 0 : _a.value) instanceof Array)
-        return attr.rhs.value.map(v => v.value).join(",");
-    if (typeof ((_b = attr.rhs) === null || _b === void 0 ? void 0 : _b.value) === 'string')
-        return unescapeString(attr.rhs.value);
-    return;
-}
-function makeDocs(node) {
-    let docs = undefined;
-    node.extAttrs.forEach(it => {
+    ///
+    isNamespace(node) {
+        return node.type === 'namespace';
+    }
+    isVersion(node) {
+        return node.type === 'version';
+    }
+    isPackage(node) {
+        return node.type === 'package';
+    }
+    isImport(node) {
+        return node.type === 'import';
+    }
+    isCallable(node) {
+        return node.extAttrs.some(it => it.name == "Invoke");
+    }
+    ///
+    extractTypeArguments(file, extAttrs, attribute) {
         var _a;
-        if (it.name == "Documentation")
-            docs = (_a = it.rhs) === null || _a === void 0 ? void 0 : _a.value;
-    });
-    return docs;
-}
-function toIDLEnum(file, node) {
-    const result = createEnum(node.name, [], {
-        fileName: file,
-        documentation: makeDocs(node),
-        extendedAttributes: toExtendedAttributes(node.extAttrs),
-    });
-    result.elements = node.values.map((it) => createEnumMember(it.value, result, IDLNumberType, undefined));
-    return result;
-}
-function findExtendedAttribute(extAttrs, name) {
-    const attr = extAttrs.find(it => it.name === name);
-    return attr ? toExtendedAttributeValue(attr) : undefined;
+        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); });
+    }
+    constantValue(node) {
+        switch (node.value.type) {
+            case "string":
+                return `"${node.value.value}"`;
+            case "number":
+                return node.value.value;
+            case "boolean":
+                return node.value.value.toString();
+            case "null":
+                return "null";
+            case "Infinity":
+                return "Infinity";
+            case "NaN":
+                return "NaN";
+            case "sequence":
+                return `[${node.value.value.join(',')}]`;
+            case "dictionary":
+                return `new Map()`;
+            default:
+                return "undefined";
+        }
+    }
+    unescapeString(value) {
+        if (!value.length || value[0] !== '"')
+            return value;
+        value = value.slice(1, -1);
+        value = value.replace(/\\((['"\\bfnrtv])|([0-7]{1-3})|x([0-9a-fA-F]{2})|u([0-9a-fA-F]{4}))/g, (_, all, c, oct, h2, u4) => {
+            if (c !== undefined) {
+                switch (c) {
+                    case "'": return "'";
+                    case '"': return '"';
+                    case "\\": return "\\";
+                    case "b": return "\b";
+                    case "f": return "\f";
+                    case "n": return "\n";
+                    case "r": return "\r";
+                    case "t": return "\t";
+                    case "v": return "\v";
+                }
+            }
+            else if (oct !== undefined) {
+                return String.fromCharCode(parseInt(oct, 8));
+            }
+            else if (h2 !== undefined) {
+                return String.fromCharCode(parseInt(h2, 16));
+            }
+            else if (u4 !== undefined) {
+                return String.fromCharCode(parseInt(u4, 16));
+            }
+            throw new Error(`unknown escape sequence: ${_}`);
+        });
+        return value;
+    }
+    makeDocs(node) {
+        let docs = undefined;
+        node.extAttrs.forEach(it => {
+            var _a;
+            if (it.name == "Documentation")
+                docs = (_a = it.rhs) === null || _a === void 0 ? void 0 : _a.value;
+        });
+        return docs;
+    }
+    findExtendedAttribute(extAttrs, name) {
+        const attr = extAttrs.find(it => it.name === name);
+        return attr ? this.toExtendedAttributeValue(attr) : undefined;
+    }
 }
 function toIDLFile(fileName, content) {
+    const lexicalInfo = new Map();
+    const deserializer = new IDLDeserializer(lexicalInfo);
     if (undefined === content)
         content = fs__namespace.readFileSync(fileName).toString();
     let packageClause = [];
@@ -7707,15 +8035,17 @@ function toIDLFile(fileName, content) {
         .filter(it => {
         if (!it.type)
             return false;
-        if (isPackage(it)) {
+        if (deserializer.isPackage(it)) {
             packageClause = it.clause.split(".");
+            deserializer.setPackage(packageClause);
             return false;
         }
         return true;
     })
-        .map(it => toIDLNode(fileName, it));
+        .map(it => deserializer.toIDLNode(fileName, it));
     const file = createFile(entries, fileName, packageClause);
-    return linkParentBack(file);
+    file.text = content;
+    return [linkParentBack(file), lexicalInfo];
 }
 
 /*
@@ -7801,6 +8131,61 @@ class BridgesConstructions {
     }
 }
 
+/*
+ * 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 Config {
+    constructor(ignore, nonNullable, irHack) {
+        this.ignore = ignore;
+        this.nonNullable = nonNullable;
+        this.irHack = irHack;
+    }
+    static get createPrefix() {
+        return `Create`;
+    }
+    static get updatePrefix() {
+        return `Update`;
+    }
+    static get constPostfix() {
+        return `Const`;
+    }
+    static get nodeTypeAttribute() {
+        return `Es2pandaAstNodeType`;
+    }
+    static get nodeNamespaceAttribute() {
+        return `cpp_namespace`;
+    }
+    static get uselessPrefix() {
+        return `Get`;
+    }
+    static get astNodeCommonAncestor() {
+        return `AstNode`;
+    }
+    static get context() {
+        return `Context`;
+    }
+    static get dataClassPrefix() {
+        return `es2panda_`;
+    }
+    static get defaultAncestor() {
+        return `ArktsObject`;
+    }
+    static get irNamespace() {
+        return `ir`;
+    }
+}
+
 /*
  * Copyright (c) 2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -7832,11 +8217,11 @@ class InteropConstructions {
         return `${parameter}SequenceLength`;
     }
     static method(interfaceName, methodName, namespaceName = "") {
-        if (Config.isCreateOrUpdate(methodName)) {
+        if (isCreateOrUpdate(methodName)) {
             const { createOrUpdate, rest } = splitCreateOrUpdate(methodName);
-            return `${createOrUpdate}${interfaceName}${capitalize(namespaceName)}${rest}`;
+            return `${createOrUpdate}${interfaceName}${rest}`;
         }
-        return `${interfaceName}${capitalize(namespaceName)}${methodName}`;
+        return `${interfaceName}${methodName}`;
     }
     static get keywords() {
         return [
@@ -7856,91 +8241,6 @@ InteropConstructions.context = {
     name: `context`
 };
 
-/*
- * 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 isString(node) {
-    return isPrimitiveType(node) && node.name === `String`;
-}
-function isSequence(node) {
-    return IDLContainerUtils.isSequence(node);
-}
-function createUpdatedInterface(node, methods, name, inheritance, extendedAttributes, properties) {
-    return createInterface(name !== null && name !== void 0 ? name : node.name, node.subkind, inheritance !== null && inheritance !== void 0 ? inheritance : node.inheritance, node.constructors, node.constants, properties !== null && properties !== void 0 ? properties : node.properties, methods !== null && methods !== void 0 ? methods : node.methods, node.callables, node.typeParameters, {
-        extendedAttributes: node.extendedAttributes,
-        fileName: node.fileName,
-        documentation: node.documentation
-    });
-}
-function createUpdatedMethod(node, name, parameters, returnType, extendedAttributes) {
-    return createMethod(name !== null && name !== void 0 ? name : node.name, parameters !== null && parameters !== void 0 ? parameters : node.parameters, returnType !== null && returnType !== void 0 ? returnType : node.returnType, {
-        isAsync: node.isAsync,
-        isFree: node.isFree,
-        isStatic: node.isStatic,
-        isOptional: node.isOptional,
-    }, {
-        extendedAttributes: node.extendedAttributes,
-        fileName: node.fileName,
-        documentation: node.documentation,
-    }, node.typeParameters);
-}
-function nodeType(node) {
-    var _a, _b;
-    return (_b = (_a = node.extendedAttributes) === null || _a === void 0 ? void 0 : _a.find(it => it.name === Config.nodeTypeAttribute)) === null || _b === void 0 ? void 0 : _b.value;
-}
-function nodeNamespace(node) {
-    var _a, _b;
-    return (_b = (_a = node.extendedAttributes) === null || _a === void 0 ? void 0 : _a.find(it => it.name === Config.nodeNamespaceAttribute)) === null || _b === void 0 ? void 0 : _b.value;
-}
-function dropNamespace(node) {
-    var _a, _b;
-    const index = (_a = node.extendedAttributes) === null || _a === void 0 ? void 0 : _a.findIndex(it => it.name === Config.nodeNamespaceAttribute);
-    if (index == undefined || index == -1)
-        return;
-    (_b = node.extendedAttributes) === null || _b === void 0 ? void 0 : _b.splice(index, 1);
-}
-function parent(node) {
-    var _a;
-    return (_a = node.inheritance[0]) === null || _a === void 0 ? void 0 : _a.name;
-}
-function createDefaultTypescriptWriter() {
-    return new TSLanguageWriter(new IndentedPrinter(), createEmptyReferenceResolver(), { convert: (node) => throwException(`unexpected type conversion`) });
-}
-function isIrNamespace(node) {
-    return nodeNamespace(node) === Config.irNamespace;
-}
-function createSequence(inner) {
-    return createContainerType(`sequence`, [inner]);
-}
-function innerType(node) {
-    return node.elementType[0];
-}
-function innerTypeIfContainer(node) {
-    if (isContainerType(node)) {
-        return innerType(node);
-    }
-    return node;
-}
-function makeMethod(name, parameters, returnType, modifiers) {
-    return new Method(name, makeSignature(parameters, returnType), modifiers !== null && modifiers !== void 0 ? modifiers : []);
-}
-function makeSignature(parameters, returnType) {
-    return new MethodSignature(returnType, parameters.map(it => it.type), undefined, undefined, parameters
-        .map(it => it.name)
-        .map(mangleIfKeyword));
-}
-
 /*
  * Copyright (c) 2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -8040,6 +8340,23 @@ function isReal(node) {
 function isDataClass(node) {
     return parent(node) === Config.defaultAncestor;
 }
+function isCreate(name) {
+    return isCreateOrUpdate(name) && name.startsWith(Config.createPrefix);
+}
+function isCreateOrUpdate(sourceMethodName) {
+    if (!sourceMethodName.startsWith(Config.createPrefix) && !sourceMethodName.startsWith(Config.updatePrefix)) {
+        return false;
+    }
+    const { rest } = splitCreateOrUpdate(sourceMethodName);
+    return rest.length <= 1;
+}
+function fixEnumPrefix(name) {
+    if (name.startsWith(`es2panda_`)) {
+        name = dropPrefix(name, `es2panda_`);
+        name = `Es2panda${name}`;
+    }
+    return name;
+}
 
 /*
  * Copyright (c) 2024 Huawei Device Co., Ltd.
@@ -8055,57 +8372,108 @@ function isDataClass(node) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-class Config {
-    constructor(ignore, nonNullable) {
-        this.ignore = ignore;
-        this.nonNullable = nonNullable;
-    }
-    static get createPrefix() {
-        return `Create`;
-    }
-    static get updatePrefix() {
-        return `Update`;
-    }
-    static get constPostfix() {
-        return `Const`;
-    }
-    static get nodeTypeAttribute() {
-        return `Es2pandaAstNodeType`;
-    }
-    static get nodeNamespaceAttribute() {
-        return `cpp_namespace`;
-    }
-    static get getterAttribute() {
-        return `get`;
-    }
-    static get uselessPrefix() {
-        return `Get`;
-    }
-    static get astNodeCommonAncestor() {
-        return `AstNode`;
-    }
-    static get context() {
-        return `Context`;
+function isString(node) {
+    return isPrimitiveType(node) && node.name === `String`;
+}
+function isSequence(node) {
+    return IDLContainerUtils.isSequence(node);
+}
+function createUpdatedInterface(node, methods, name, inheritance, extendedAttributes, properties) {
+    return createInterface(name !== null && name !== void 0 ? name : node.name, node.subkind, inheritance !== null && inheritance !== void 0 ? inheritance : node.inheritance, node.constructors, node.constants, properties !== null && properties !== void 0 ? properties : node.properties, methods !== null && methods !== void 0 ? methods : node.methods, node.callables, node.typeParameters, {
+        extendedAttributes: extendedAttributes !== null && extendedAttributes !== void 0 ? extendedAttributes : node.extendedAttributes,
+        fileName: node.fileName,
+        documentation: node.documentation
+    });
+}
+function baseName(type) {
+    return baseNameString(type.name);
+}
+function baseNameString(name) {
+    if (name.indexOf('.') > 0) {
+        return name.substring(name.lastIndexOf('.') + 1);
     }
-    static isCreate(name) {
-        return Config.isCreateOrUpdate(name) && name.startsWith(Config.createPrefix);
+    else {
+        return name;
     }
-    static isCreateOrUpdate(sourceMethodName) {
-        if (!sourceMethodName.startsWith(Config.createPrefix) && !sourceMethodName.startsWith(Config.updatePrefix)) {
-            return false;
+}
+// A bit of a hack, use namespaces for real later.
+function flattenType(type) {
+    if (isUnionType(type))
+        return createUnionType(type.types.map(flattenType), type.name);
+    if (isOptionalType(type))
+        return createOptionalType(flattenType(type.type));
+    if (isContainerType(type))
+        return createContainerType(type.containerKind, type.elementType.map(flattenType));
+    if (isReferenceType(type)) {
+        if (type.name.indexOf(".") > 0) {
+            let result = createReferenceType(baseName(type));
+            //console.log(`flatten ${type.name} to ${result.name}`)
+            return result;
         }
-        const { rest } = splitCreateOrUpdate(sourceMethodName);
-        return rest.length <= 1;
     }
-    static get dataClassPrefix() {
-        return `es2panda_`;
+    return type;
+}
+function createUpdatedMethod(node, name, parameters, returnType, extendedAttributes) {
+    return createMethod(name !== null && name !== void 0 ? name : node.name, parameters !== null && parameters !== void 0 ? parameters : node.parameters, returnType !== null && returnType !== void 0 ? returnType : node.returnType, {
+        isAsync: node.isAsync,
+        isFree: node.isFree,
+        isStatic: node.isStatic,
+        isOptional: node.isOptional,
+    }, {
+        extendedAttributes: node.extendedAttributes,
+        fileName: node.fileName,
+        documentation: node.documentation,
+    }, node.typeParameters);
+}
+function nodeType(node) {
+    var _a, _b;
+    return (_b = (_a = node.extendedAttributes) === null || _a === void 0 ? void 0 : _a.find(it => it.name === Config.nodeTypeAttribute)) === null || _b === void 0 ? void 0 : _b.value;
+}
+function nodeNamespace(node) {
+    var _a;
+    return (_a = getNamespacesPathFor(node)[0]) === null || _a === void 0 ? void 0 : _a.name;
+}
+function parent(node) {
+    var _a;
+    return (_a = node.inheritance[0]) === null || _a === void 0 ? void 0 : _a.name;
+}
+function createDefaultTypescriptWriter() {
+    return new TSLanguageWriter(new IndentedPrinter(), createEmptyReferenceResolver(), { convert: (node) => throwException(`unexpected type conversion`) });
+}
+function isIrNamespace(node) {
+    var _a, _b;
+    let cppNamespace = (_b = (_a = node.extendedAttributes) === null || _a === void 0 ? void 0 : _a.find(it => it.name == Config.nodeNamespaceAttribute)) === null || _b === void 0 ? void 0 : _b.value;
+    return nodeNamespace(node) === Config.irNamespace || cppNamespace == Config.irNamespace;
+}
+function createSequence(inner) {
+    return createContainerType(`sequence`, [inner]);
+}
+function innerType(node) {
+    return node.elementType[0];
+}
+function innerTypeIfContainer(node) {
+    if (isContainerType(node)) {
+        return innerType(node);
     }
-    static get defaultAncestor() {
-        return `ArktsObject`;
+    return node;
+}
+function makeMethod(name, parameters, returnType, modifiers) {
+    return new Method(name, makeSignature(parameters, returnType), modifiers !== null && modifiers !== void 0 ? modifiers : []);
+}
+function makeSignature(parameters, returnType) {
+    let parameterModifiers = parameters.map(it => it.isOptional || isOptionalType(it.type) ? ArgumentModifier.OPTIONAL : undefined);
+    let lastNonOptional = -1;
+    for (let i = 0; i < parameterModifiers.length; i++) {
+        if (parameterModifiers[i] == undefined)
+            lastNonOptional = i;
     }
-    static get irNamespace() {
-        return `ir`;
+    if (lastNonOptional != -1) {
+        for (let i = 0; i < lastNonOptional; i++)
+            parameterModifiers[i] = undefined;
     }
+    return new MethodSignature(returnType, parameters.map(it => it.type), undefined, parameterModifiers, undefined, parameters
+        .map(it => it.name)
+        .map(mangleIfKeyword));
 }
 
 /*
@@ -8125,16 +8493,19 @@ class Config {
 class Typechecker {
     constructor(idl) {
         this.idl = idl;
+        this.idl = linearizeNamespaceMembers(idl);
     }
     findRealDeclaration(name) {
-        const declarations = this.idl.filter(it => name === it.name);
+        // Poor man's namespace-aware resolve.
+        // TODO: REWORK IT ALL!
+        const declarations = this.idl.filter(it => (name === it.name) || (baseNameString(name) == baseNameString(it.name)));
         if (declarations.length === 1) {
             return declarations[0];
         }
         const ir = declarations
             .filter(isInterface$1)
             .filter(it => isIrNamespace(it));
-        if (ir.length === 1) {
+        if (ir.length > 0) {
             return ir[0];
         }
         return undefined;
@@ -8151,31 +8522,95 @@ class Typechecker {
         if (parent === undefined) {
             return declaration.name === ancestor;
         }
-        return this.isHeir(parent.name, ancestor);
+        return this.isHeir(parent.name, ancestor);
+    }
+    isPeer(node) {
+        if (node === Config.astNodeCommonAncestor)
+            return false; // TODO: is handwritten
+        if (node === Config.context)
+            return false; // TODO: is handwritten
+        if (this.isHeir(node, Config.astNodeCommonAncestor))
+            return true;
+        if (this.isHeir(node, Config.defaultAncestor))
+            return true;
+        return false;
+    }
+    isReferenceTo(type, isTarget) {
+        if (!isReferenceType(type)) {
+            return false;
+        }
+        const declaration = this.findRealDeclaration(type.name);
+        return declaration !== undefined && isTarget(declaration);
+    }
+    isConstReturnValue(node) {
+        if (isPrimitiveType(node.returnType) || this.isReferenceTo(node.returnType, isEnum$1)) {
+            return false;
+        }
+        return node.name.endsWith(Config.constPostfix);
+    }
+    nodeTypeName(node) {
+        var _a, _b;
+        const value = nodeType(node);
+        const idlEnum = this.idl
+            .filter(isEnum$1)
+            .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;
+    }
+}
+
+/*
+ * 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 AbstractVisitor {
+    visitChildren(entry) {
+        if (isFile(entry)) {
+            entry.entries.forEach(it => this.visit(it));
+        }
+        if (isNamespace(entry)) {
+            entry.members.forEach(it => this.visit(it));
+        }
     }
-    isPeer(node) {
-        if (node === Config.astNodeCommonAncestor)
-            return false; // TODO: is handwritten
-        if (node === Config.context)
-            return false; // TODO: is handwritten
-        if (this.isHeir(node, Config.astNodeCommonAncestor))
-            return true;
-        if (this.isHeir(node, Config.defaultAncestor))
-            return true;
-        return false;
+}
+class SingleFilePrinter extends AbstractVisitor {
+    constructor(idl) {
+        super();
+        this.idl = idl;
+        this.typechecker = new Typechecker(this.idl.entries);
     }
-    isReferenceTo(type, isTarget) {
-        if (!isReferenceType(type)) {
-            return false;
+    printEnum(node) { }
+    visit(node) {
+        if (isInterface$1(node) && !this.filterInterface(node)) {
+            this.printInterface(node);
         }
-        const declaration = this.findRealDeclaration(type.name);
-        return declaration !== undefined && isTarget(declaration);
-    }
-    isConstReturnValue(node) {
-        if (isPrimitiveType(node.returnType) || this.isReferenceTo(node.returnType, isEnum$1)) {
-            return false;
+        if (isEnum$1(node)) {
+            this.printEnum(node);
         }
-        return node.name.endsWith(Config.constPostfix);
+        this.visitChildren(node);
+    }
+    prologue() { }
+    epilogue() { }
+    print() {
+        var _a, _b;
+        this.prologue();
+        this.visit(this.idl);
+        this.epilogue();
+        return [
+            (_b = (_a = this.importer) === null || _a === void 0 ? void 0 : _a.getOutput()) !== null && _b !== void 0 ? _b : [],
+            this.writer.getOutput()
+        ]
+            .flat()
+            .join(`\n`);
     }
 }
 
@@ -8193,8 +8628,9 @@ class Typechecker {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-class InteropPrinter {
+class InteropPrinter extends AbstractVisitor {
     constructor(file) {
+        super();
         this.file = file;
         this.typechecker = new Typechecker(this.file.entries);
     }
@@ -8204,23 +8640,17 @@ class InteropPrinter {
     }
     visit(node) {
         if (isInterface$1(node)) {
-            return this.visitInterface(node);
-        }
-        if (isEnum$1(node)) {
-            return;
-        }
-        if (isTypedef$1(node)) {
-            return;
+            this.visitInterface(node);
         }
-        throwException(`Unexpected top-level node: ${IDLKind[node.kind]}`);
+        this.visitChildren(node);
     }
     visitInterface(node) {
-        node.methods.forEach(it => this.visitMethod(it));
+        node.methods.forEach(it => this.visitMethod(node, it));
     }
-    visitMethod(node) {
-        this.printMethod(node);
+    visitMethod(iface, node) {
+        this.printMethod(iface, node);
     }
-    printMethod(node) { }
+    printMethod(iface, node) { }
 }
 
 /*
@@ -8251,9 +8681,11 @@ class BaseTypeConvertor {
     convertPrimitiveType(type) {
         switch (type) {
             case IDLI8Type: return this.conversions.i8(type);
+            case IDLU8Type: return this.conversions.iu8(type);
             case IDLI16Type: return this.conversions.i16(type);
             case IDLI32Type: return this.conversions.i32(type);
             case IDLU32Type: return this.conversions.iu32(type);
+            case IDLU64Type: return this.conversions.iu64(type);
             case IDLI64Type: return this.conversions.i64(type);
             case IDLF32Type: return this.conversions.f32(type);
             case IDLF64Type: return this.conversions.f64(type);
@@ -8264,6 +8696,9 @@ class BaseTypeConvertor {
         }
         throwException(`unsupported primitive type: ${JSON.stringify(type)}`);
     }
+    convertTypeReferenceAsImport(type, importClause) {
+        return this.convertTypeReference(type);
+    }
     convertTypeReference(type) {
         if (this.typechecker.isReferenceTo(type, isEnum$1)) {
             return this.conversions.enum(type);
@@ -8276,8 +8711,8 @@ class BaseTypeConvertor {
     convertUnion(type) {
         throwException("union type is not supported");
     }
-    convertImport(type, importClause) {
-        throw new Error("import is not supported");
+    convertImport(type) {
+        throw new Error("Import is not supported");
     }
     convertTypeParameter(type) {
         throw new Error("type parameters are not supported");
@@ -8313,6 +8748,7 @@ let ReturnTypeConvertor$1 = class ReturnTypeConvertor extends BaseTypeConvertor
             reference: (type) => type,
             optional: (type) => type,
             i8: (type) => type,
+            iu8: (type) => type,
             i16: (type) => type,
             i32: (type) => type,
             iu32: (type) => type,
@@ -8343,7 +8779,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`, 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`), 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));
     }
 }
 
@@ -8415,6 +8851,7 @@ class CastTypeConvertor extends BaseTypeConvertor {
             enum: (type) => BridgesConstructions.enumCast(this.castToTypeConvertor.convertType(type)),
             reference: (type) => BridgesConstructions.referenceTypeCast(this.castToTypeConvertor.convertType(type)),
             i8: primitive,
+            iu8: primitive,
             i16: primitive,
             i32: primitive,
             iu32: primitive,
@@ -8437,10 +8874,13 @@ class CastToTypeConvertor extends BaseTypeConvertor {
         super(typechecker, {
             sequence: (type) => BridgesConstructions.arrayOf(this.convertType(innerType(type))),
             enum: (type) => type.name,
-            reference: (type) => BridgesConstructions.referenceType(typechecker.isHeir(type.name, Config.astNodeCommonAncestor)
-                ? Config.astNodeCommonAncestor
-                : type.name),
+            reference: (type) => {
+                return BridgesConstructions.referenceType(typechecker.isHeir(type.name, Config.astNodeCommonAncestor)
+                    ? Config.astNodeCommonAncestor
+                    : baseName(type));
+            },
             i8: primitive,
+            iu8: primitive,
             i16: primitive,
             i32: primitive,
             iu32: primitive,
@@ -8450,7 +8890,7 @@ class CastToTypeConvertor extends BaseTypeConvertor {
             f64: primitive,
             boolean: primitive,
             optional: (type) => throwException(`no optional type allowed at interop level conversion`),
-            string: (type) => throwException(`string parameters are casted by copying`),
+            string: (type) => "const char*",
             void: (type) => throwException(`no void typed parameters allowed`),
             pointer: (type) => throwException(`no pointer typed parameters allowed`)
         });
@@ -8473,8 +8913,9 @@ class CastToTypeConvertor extends BaseTypeConvertor {
  * limitations under the License.
  */
 class BridgesPrinter extends InteropPrinter {
-    constructor() {
-        super(...arguments);
+    constructor(config, file) {
+        super(file);
+        this.config = config;
         this.castTypeConvertor = new CastTypeConvertor(this.typechecker);
         this.nativeTypeConvertor = new NativeTypeConvertor(this.typechecker);
         this.writer = new CppLanguageWriter(new IndentedPrinter(), createEmptyReferenceResolver(), { convert: (node) => this.nativeTypeConvertor.convertType(node) }, new class extends PrimitiveTypeList {
@@ -8499,15 +8940,15 @@ class BridgesPrinter extends InteropPrinter {
             .map(it => this.interopMacroConvertor.convertType(it)))
             .map(it => this.writer.makeString(it))));
     }
-    printMethod(node) {
-        this.writer.writeFunctionImplementation(BridgesConstructions.implFunction(node.name), new MethodSignature(this.returnTypeConvertor.convertType(node.returnType), node.parameters.map(it => it.type), undefined, undefined, node.parameters.map(it => it.name)), (_) => this.printBody(node));
+    printMethod(iface, node) {
+        this.writer.writeFunctionImplementation(BridgesConstructions.implFunction(node.name), new MethodSignature(this.returnTypeConvertor.convertType(node.returnType), node.parameters.map(it => it.type), undefined, node.parameters.map(it => it.isOptional ? ArgumentModifier.OPTIONAL : undefined), undefined, node.parameters.map(it => it.name)), (_) => this.printBody(iface, node));
         this.printInteropMacro(node);
         this.writer.writeLines(``);
     }
-    printBody(node) {
+    printBody(iface, node) {
         this.printParameters(node);
         this.printDeclarations(node);
-        this.printEs2pandaCall(node);
+        this.printEs2pandaCall(iface, node);
         this.printReturn(node);
     }
     printParameters(node) {
@@ -8519,15 +8960,18 @@ class BridgesPrinter extends InteropPrinter {
             this.writer.writeExpressionStatement(this.writer.makeString(BridgesConstructions.sequenceLengthDeclaration));
         }
     }
-    printEs2pandaCall(node) {
+    printEs2pandaCall(iface, node) {
         if (isVoidType(node.returnType)) {
-            this.writer.writeExpressionStatement(this.makeEs2pandaMethodCall(node));
+            this.writer.writeExpressionStatement(this.makeEs2pandaMethodCall(iface, node));
             return;
         }
-        this.writer.writeExpressionStatement(this.writer.makeString(BridgesConstructions.resultAssignment(this.makeEs2pandaMethodCall(node).asString())));
+        this.writer.writeExpressionStatement(this.writer.makeString(BridgesConstructions.resultAssignment(this.makeEs2pandaMethodCall(iface, node).asString())));
     }
-    makeEs2pandaMethodCall(node) {
-        return this.writer.makeFunctionCall(BridgesConstructions.callMethod(node.name), node.parameters
+    makeEs2pandaMethodCall(iface, node) {
+        let suffix = this.config.irHack.isIrHackInterface(iface.name) ? 'Ir' : '';
+        let method = BridgesConstructions.callMethod(node.name);
+        method = method.replace(iface.name, iface.name + suffix);
+        return this.writer.makeFunctionCall(method, node.parameters
             .map(it => ({
             asString: () => BridgesConstructions.castedParameter(it.name),
         }))
@@ -8559,37 +9003,6 @@ class BridgesPrinter extends InteropPrinter {
     }
 }
 
-/*
- * 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 SingleFilePrinter {
-    constructor(idl) {
-        this.idl = idl;
-        this.typechecker = new Typechecker(this.idl.entries);
-    }
-    print() {
-        var _a, _b;
-        this.visit();
-        return [
-            (_b = (_a = this.importer) === null || _a === void 0 ? void 0 : _a.getOutput()) !== null && _b !== void 0 ? _b : [],
-            this.writer.getOutput()
-        ]
-            .flat()
-            .join(`\n`);
-    }
-}
-
 /*
  * Copyright (c) 2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -8630,13 +9043,12 @@ class EnumsPrinter extends SingleFilePrinter {
         super(...arguments);
         this.writer = new TSLanguageWriter(new IndentedPrinter(), createEmptyReferenceResolver(), { convert: (node) => { throwException(`Unexpected call to covert type`); } });
     }
-    visit() {
-        this.idl.entries
-            .filter(isEnum$1)
-            .forEach(it => this.printEnum(it));
+    printInterface(node) { }
+    filterInterface(node) {
+        return true;
     }
     printEnum(node) {
-        this.writer.writeEnum(node.name, node.elements.map(it => {
+        this.writer.writeEnum(fixEnumPrefix(node.name), node.elements.map(it => {
             if (!isNumber(it.initializer)) {
                 throwException(`unexpected initializer value: ${it.initializer}`);
             }
@@ -8645,7 +9057,7 @@ class EnumsPrinter extends SingleFilePrinter {
                 stringId: undefined,
                 numberId: it.initializer,
             };
-        }));
+        }), { isExport: true });
     }
 }
 
@@ -8668,11 +9080,8 @@ class IndexPrinter extends SingleFilePrinter {
         super(...arguments);
         this.writer = createDefaultTypescriptWriter();
     }
-    visit() {
-        this.idl.entries
-            .filter(isInterface$1)
-            .filter(it => this.typechecker.isPeer(it.name))
-            .forEach(it => this.printInterface(it));
+    filterInterface(node) {
+        return !this.typechecker.isPeer(node.name);
     }
     printInterface(node) {
         this.writer.writeExpressionStatement(this.writer.makeString(`export * from "./peers/${node.name}"`));
@@ -8750,6 +9159,7 @@ class ReturnTypeConvertor extends BaseTypeConvertor {
             reference: (type) => type,
             optional: (type) => type,
             i8: (type) => type,
+            iu8: (type) => type,
             i16: (type) => type,
             i32: (type) => type,
             iu32: (type) => type,
@@ -8787,8 +9197,8 @@ class BindingsPrinter extends InteropPrinter {
         this.returnConvertor = new ReturnTypeConvertor(this.typechecker);
         this.writer.pushIndent();
     }
-    printMethod(node) {
-        this.writer.writeMethodImplementation(new Method(BindingsConstructions.method(node.name), new MethodSignature(this.returnConvertor.convertType(node.returnType), node.parameters.map(it => it.type), undefined, undefined, node.parameters.map(it => it.name))), (writer) => {
+    printMethod(iface, node) {
+        this.writer.writeMethodImplementation(new Method(BindingsConstructions.method(node.name), new MethodSignature(this.returnConvertor.convertType(node.returnType), node.parameters.map(it => it.type), undefined, node.parameters.map(it => it.isOptional ? ArgumentModifier.OPTIONAL : undefined), undefined, node.parameters.map(it => it.name))), (writer) => {
             writer.writeExpressionStatement(writer.makeString(BindingsConstructions.unimplemented));
         });
     }
@@ -8808,10 +9218,22 @@ class BindingsPrinter extends InteropPrinter {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-class MultiFilePrinter {
+class MultiFilePrinter extends AbstractVisitor {
     constructor(idl) {
+        super();
         this.idl = idl;
         this.typechecker = new Typechecker(this.idl.entries);
+        this.output = [];
+    }
+    visit(node) {
+        if (isInterface$1(node) && !this.filterInterface(node)) {
+            this.output.push(this.printInterface(node));
+        }
+        this.visitChildren(node);
+    }
+    print() {
+        this.visit(this.idl);
+        return this.output;
     }
 }
 
@@ -8938,8 +9360,7 @@ class Importer {
         this.writer = createDefaultTypescriptWriter();
         this.seen = new Set([
             Config.astNodeCommonAncestor,
-            Config.defaultAncestor,
-            `Es2pandaAstNodeType` // TODO: remove once enum generation is fixed
+            Config.defaultAncestor, // TODO: handwritten
         ]);
         if (self !== undefined) {
             this.seen.add(self);
@@ -8990,6 +9411,7 @@ class TopLevelTypeConvertor extends BaseTypeConvertor {
     constructor(typechecker, heirConversions) {
         super(typechecker, Object.assign(Object.assign({}, heirConversions), {
             i8: heirConversions.number,
+            iu8: heirConversions.number,
             i16: heirConversions.number,
             i32: heirConversions.number,
             iu32: heirConversions.number,
@@ -9064,7 +9486,7 @@ class ImporterTypeConvertor extends TopLevelTypeConvertor {
                 return type;
             },
             reference: (type) => {
-                this.importer.withPeerImport(type.name);
+                this.importer.withPeerImport(baseName(type));
                 return type;
             },
             string: (type) => type,
@@ -9172,29 +9594,34 @@ class BindingReturnValueTypeConvertor extends TopLevelTypeConvertor {
  * limitations under the License.
  */
 class PeerPrinter extends SingleFilePrinter {
-    constructor(idl, node) {
-        var _a;
+    printInterface(node) {
+        if (node != this.node)
+            throw new Error("Must match");
+        this.printPeer();
+        if (!isDataClass(this.node)) {
+            this.printTypeGuard();
+        }
+        if (isReal(this.node)) {
+            this.printAddToNodeMap();
+        }
+    }
+    filterInterface(node) {
+        return node != this.node;
+    }
+    constructor(config, idl, node) {
         super(idl);
+        this.config = config;
         this.node = node;
         this.typechecker = new Typechecker(this.idl.entries);
         this.importer = new Importer(this.typechecker, `.`, this.node.name);
         this.bindingParameterTypeConvertor = new BindingParameterTypeConvertor(this.typechecker);
         this.bindingReturnValueTypeConvertor = new BindingReturnValueTypeConvertor(this.typechecker);
-        this.parent = (_a = parent(this.node)) !== null && _a !== void 0 ? _a : throwException(`expected peer to have parent: ${this.node.name}`);
+        this.parent = parent(this.node); // ?? throwException(`expected peer to have parent: ${this.node.name}`)
         this.writer = new TSLanguageWriter(new IndentedPrinter(), createEmptyReferenceResolver(), { convert: (node) => composedConvertType(new LibraryTypeConvertor(this.typechecker), new ImporterTypeConvertor(this.importer, this.typechecker), node)
         });
     }
-    visit() {
-        this.printPeer();
-        if (!isDataClass(this.node)) {
-            this.printTypeGuard();
-        }
-        if (isReal(this.node)) {
-            this.printAddToNodeMap();
-        }
-    }
     printPeer() {
-        this.writer.writeClass(this.node.name, () => this.printBody(), this.importer.withPeerImport(this.parent));
+        this.writer.writeClass(this.node.name, () => this.printBody(), this.parent ? this.importer.withPeerImport(this.parent) : undefined);
     }
     printBody() {
         this.printConstructor();
@@ -9203,7 +9630,7 @@ class PeerPrinter extends SingleFilePrinter {
     printConstructor() {
         this.writer.writeConstructorImplementation(this.node.name, new MethodSignature(IDLVoidType, [
             IDLPointerType
-        ], undefined, undefined, [
+        ], undefined, undefined, undefined, [
             PeersConstructions.pointerParameter
         ]), () => {
             var _a;
@@ -9219,13 +9646,13 @@ class PeerPrinter extends SingleFilePrinter {
         });
     }
     printTypeGuard() {
-        this.writer.writeFunctionImplementation(PeersConstructions.typeGuard.name(this.node.name), new MethodSignature(createReferenceType(PeersConstructions.typeGuard.returnType(this.node.name)), [createReferenceType(PeersConstructions.typeGuard.parameter.type)], undefined, undefined, [PeersConstructions.typeGuard.parameter.name]), () => {
+        this.writer.writeFunctionImplementation(PeersConstructions.typeGuard.name(this.node.name), new MethodSignature(createReferenceType(PeersConstructions.typeGuard.returnType(this.node.name)), [createReferenceType(PeersConstructions.typeGuard.parameter.type)], undefined, undefined, undefined, [PeersConstructions.typeGuard.parameter.name]), () => {
             this.writer.writeStatement(this.writer.makeReturn(this.writer.makeString(PeersConstructions.typeGuard.body(this.node.name))));
         });
     }
     printMethods() {
         this.node.methods.forEach(it => {
-            if (Config.isCreateOrUpdate(it.name)) {
+            if (isCreateOrUpdate(it.name)) {
                 if (isAbstract(this.node)) {
                     return;
                 }
@@ -9240,13 +9667,13 @@ class PeerPrinter extends SingleFilePrinter {
         });
     }
     printGetter(node) {
-        this.writer.writeMethodImplementation(new Method(peerMethod(node.name), new MethodSignature(node.returnType, []), [MethodModifier.GETTER]), () => {
+        this.writer.writeMethodImplementation(new Method(peerMethod(node.name), new MethodSignature(flattenType(node.returnType), []), [MethodModifier.GETTER]), () => {
             this.writer.writeStatement(this.writer.makeReturn(this.makeReturnBindingCall(node)));
         });
     }
     printRegular(node) {
         this.writer.writeExpressionStatement(this.writer.makeString(`/** @deprecated */`));
-        this.writer.writeMethodImplementation(makeMethod(peerMethod(node.name), node.parameters, PeersConstructions.this.type), () => {
+        this.writer.writeMethodImplementation(makeMethod(peerMethod(node.name), node.parameters.map(it => createParameter(it.name, flattenType(it.type))), flattenType(PeersConstructions.this.type)), () => {
             this.writer.writeExpressionStatement(this.makeReturnBindingCall(node));
             this.writer.writeStatement(this.writer.makeReturn(this.writer.makeString(PeersConstructions.this.name)));
         });
@@ -9259,7 +9686,7 @@ class PeerPrinter extends SingleFilePrinter {
         return this.bindingReturnValueTypeConvertor.convertType(node.returnType)(this.writer, nativeCall);
     }
     printCreateOrUpdate(node) {
-        this.writer.writeMethodImplementation(makeMethod(PeersConstructions.createOrUpdate(this.node.name, node.name), node.parameters, node.returnType, [MethodModifier.STATIC]), () => {
+        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, [
                 this.writer.makeFunctionCall(this.writer.makeString(PeersConstructions.callBinding(this.node.name, node.name, nodeNamespace(this.node))), this.makeBindingArguments(node.parameters))
             ])));
@@ -9275,7 +9702,12 @@ class PeerPrinter extends SingleFilePrinter {
             .map(it => this.writer.makeString(it));
     }
     printAddToNodeMap() {
-        this.writer.writeExpressionStatements(this.writer.makeString(`if (!nodeByType.has(${nodeType(this.node)})) {`), this.writer.makeString(`    nodeByType.set(${nodeType(this.node)}, ${this.node.name})`), this.writer.makeString(`}`));
+        const enumValue = this.typechecker.nodeTypeName(this.node);
+        if (enumValue === undefined) {
+            return;
+        }
+        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(`}`));
     }
 }
 
@@ -9294,16 +9726,17 @@ class PeerPrinter extends SingleFilePrinter {
  * limitations under the License.
  */
 class AllPeersPrinter extends MultiFilePrinter {
-    print() {
-        return this.idl.entries
-            .filter(isInterface$1)
-            .filter(it => this.typechecker.isPeer(it.name))
-            .map(it => this.printInterface(it));
+    constructor(config, idl) {
+        super(idl);
+        this.config = config;
+    }
+    filterInterface(node) {
+        return !this.typechecker.isPeer(node.name);
     }
     printInterface(node) {
         return {
             fileName: PeersConstructions.fileName(node.name),
-            output: new PeerPrinter(this.idl, node).print()
+            output: new PeerPrinter(this.config, this.idl, node).print()
         };
     }
 }
@@ -9364,36 +9797,41 @@ class FactoryPrinter extends SingleFilePrinter {
         this.writer = new TSLanguageWriter(new IndentedPrinter(), createEmptyReferenceResolver(), { convert: (node) => composedConvertType(new LibraryTypeConvertor(this.typechecker), new ImporterTypeConvertor(this.importer, this.typechecker), node)
         });
     }
-    withFactoryDeclaration(prints) {
+    prologue() {
         this.writer.writeExpressionStatements(this.writer.makeString(FactoryConstructions.prologue));
-        prints.forEach(it => this.writer.printer.withIndent((printer) => {
-            it();
-            printer.print(`,`);
-        }));
+        this.writer.pushIndent();
+    }
+    epilogue() {
+        this.writer.popIndent();
         this.writer.writeExpressionStatements(this.writer.makeString(FactoryConstructions.epilogue));
     }
-    visit() {
-        this.withFactoryDeclaration(this.idl.entries
-            .filter(isInterface$1)
-            .filter(it => this.typechecker.isPeer(it.name))
-            .filter(it => FactoryPrinter.getUniversalCreate(it) !== undefined)
-            .flatMap(it => [
-            () => this.printCreate(it),
-            () => this.printUpdate(it)
-        ]));
+    filterInterface(node) {
+        return !this.typechecker.isPeer(node.name) || FactoryPrinter.getUniversalCreate(node) == undefined;
+    }
+    printInterface(node) {
+        this.printCreate(node);
+        this.writer.print(',');
+        this.printUpdate(node);
+        this.writer.print(',');
     }
     printCreate(node) {
-        this.writer.writeMethodImplementation(makeMethod(PeersConstructions.universalCreate(node.name), node.properties, createReferenceType(node.name)), () => this.writer.writeStatement(this.writer.makeReturn(this.writer.makeFunctionCall(FactoryPrinter.callUniversalCreate(node), node.properties
+        this.writer.writeMethodImplementation(makeMethod(PeersConstructions.universalCreate(node.name), this.makeParameters(node.properties), flattenType(createReferenceType(node.name))), () => this.writer.writeStatement(this.writer.makeReturn(this.writer.makeFunctionCall(FactoryPrinter.callUniversalCreate(node), node.properties
             .map(it => it.name)
             .map(mangleIfKeyword)
             .map(it => this.writer.makeString(it))))));
     }
+    makeParameters(properties) {
+        // We may need to ensure optional parameters are at the end
+        return properties
+            .map(it => createParameter(it.name, flattenType(it.type), it.isOptional));
+    }
     printUpdate(node) {
         this.writer.writeMethodImplementation(makeMethod(PeersConstructions.universalUpdate(node.name), [{
                 name: FactoryConstructions.original,
-                type: id(createReferenceType(node.name))
+                type: id(flattenType(createReferenceType(node.name))),
+                isOptional: false
             }]
-            .concat(node.properties), createReferenceType(node.name)), () => {
+            .concat(this.makeParameters(node.properties)), flattenType(createReferenceType(node.name))), () => {
             this.printUnchangedBranch(node);
             this.printChangedBranch(node);
         });
@@ -9420,7 +9858,7 @@ class FactoryPrinter extends SingleFilePrinter {
         return PeersConstructions.callPeerMethod(node.name, PeersConstructions.createOrUpdate(node.name, (_b = (_a = FactoryPrinter.getUniversalCreate(node)) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : throwException(`unexpected node with no universal create`)));
     }
     static getUniversalCreate(node) {
-        const creates = node.methods.filter(it => Config.isCreate(it.name));
+        const creates = node.methods.filter(it => isCreate(it.name));
         if (creates.length !== 1) {
             return undefined;
         }
@@ -9445,24 +9883,66 @@ class FactoryPrinter extends SingleFilePrinter {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-class BaseInterfaceFilterTransformer {
-    constructor(file) {
+class Transformer {
+    constructor(file, removeNamespaces = false) {
         this.file = file;
-        this.typechecker = new Typechecker(this.file.entries);
+        this.removeNamespaces = removeNamespaces;
+    }
+    transformFile(input) {
+        let entries = this.removeNamespaces ?
+            linearizeNamespaceMembers(input.entries).filter(it => !isNamespace(it)) : input.entries;
+        let file = createFile(entries
+            .map(it => this.transformDeep(it))
+            .filter(isDefined), input.fileName);
+        linkParentBack(file);
+        return file;
+    }
+    transformDeep(entry) {
+        if (isNamespace(entry)) {
+            return createNamespace(entry.name, entry.members
+                .map(it => this.transformDeep(it))
+                .filter(isDefined));
+        }
+        return this.transform(entry);
+    }
+    transform(entry) {
+        if (isInterface$1(entry))
+            return this.transformInterface(entry);
+        else
+            return entry;
     }
     transformed() {
-        return createFile(this.file.entries
-            .flatMap(entry => {
-            if (!isInterface$1(entry)) {
-                return entry;
-            }
-            if (this.shouldFilterOutInterface(entry.name)) {
-                return [];
-            }
-            return createUpdatedInterface(entry, entry.methods
-                .filter(it => !this.shouldFilterOutMethod(entry.name, it.name))
-                .filter(it => !this.isReferringForbiddenOrMissing(it, (name) => this.shouldFilterOutInterface(name))));
-        }), this.file.fileName);
+        return this.transformFile(this.file);
+    }
+}
+
+/*
+ * 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 BaseInterfaceFilterTransformer extends Transformer {
+    constructor(file, removeNamespaces = false) {
+        super(file, removeNamespaces);
+        this.typechecker = new Typechecker(this.file.entries);
+    }
+    transformInterface(entry) {
+        if (this.shouldFilterOutInterface(entry.name)) {
+            return undefined;
+        }
+        return createUpdatedInterface(entry, entry.methods
+            .filter(it => !this.shouldFilterOutMethod(entry.name, it.name))
+            .filter(it => !this.isReferringForbiddenOrMissing(it, (name) => this.shouldFilterOutInterface(name))), entry.name, entry.inheritance, entry.extendedAttributes, entry.properties
+            .filter(it => !this.shouldFilterOutProperty(entry.name, it.name)));
     }
     isReferringForbiddenOrMissing(node, predicate) {
         return node.parameters
@@ -9479,8 +9959,7 @@ class BaseInterfaceFilterTransformer {
                 }
             }
             return false;
-        })
-            .length !== 0;
+        }).length !== 0;
     }
 }
 
@@ -9504,10 +9983,13 @@ class OptionsFilterTransformer extends BaseInterfaceFilterTransformer {
         this.config = config;
     }
     shouldFilterOutInterface(name) {
-        return !this.config.ignore.shouldEmitInterface(name);
+        return this.config.ignore.isIgnoredInterface(name);
     }
     shouldFilterOutMethod(node, name) {
-        return !this.config.ignore.shouldEmitMethod(node, name);
+        return this.config.ignore.isIgnoredMethod(node, name);
+    }
+    shouldFilterOutProperty(node, name) {
+        return this.config.ignore.isIgnoredProperty(node, name);
     }
 }
 
@@ -9525,18 +10007,23 @@ class OptionsFilterTransformer extends BaseInterfaceFilterTransformer {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-class AddContextDeclarationTransformer {
+class AddContextDeclarationTransformer extends Transformer {
     constructor(file) {
-        this.file = file;
+        super(file);
+    }
+    transformInterface(entry) {
+        return entry;
     }
     transformed() {
-        return createFile(this.file.entries
+        let file = createFile(this.file.entries
             .concat(createInterface(Config.context, IDLInterfaceSubkind.Class, undefined, undefined, undefined, undefined, undefined, undefined, undefined, {
             extendedAttributes: [{
                     name: Config.nodeNamespaceAttribute,
                     value: Config.irNamespace
                 }]
         })));
+        linkParentBack(file);
+        return file;
     }
 }
 
@@ -9554,30 +10041,27 @@ class AddContextDeclarationTransformer {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-class MultipleDeclarationFilterTransformer {
+class MultipleDeclarationFilterTransformer extends Transformer {
     constructor(file) {
-        this.file = file;
-    }
-    transformed() {
-        const seen = new Map();
-        this.file.entries.forEach(it => {
+        super(file);
+        this.seen = new Map();
+        // TODO: namespaces
+        linearizeNamespaceMembers(this.file.entries).forEach(it => {
             var _a;
-            const oldValue = (_a = seen.get(it.name)) !== null && _a !== void 0 ? _a : 0;
-            seen.set(it.name, oldValue + 1);
+            let name = baseNameString(it.name);
+            const oldValue = (_a = this.seen.get(name)) !== null && _a !== void 0 ? _a : 0;
+            this.seen.set(name, oldValue + 1);
         });
-        return createFile(this.file.entries.filter(it => {
-            var _a;
-            if (!isInterface$1(it)) {
-                return it;
-            }
-            const occurence = (_a = seen.get(it.name)) !== null && _a !== void 0 ? _a : 0;
-            if (occurence < 2) {
-                dropNamespace(it);
-            }
-            if (occurence > 1 && nodeNamespace(it) != "ir")
-                return undefined;
-            return it;
-        }), this.file.fileName);
+    }
+    transformInterface(entry) {
+        var _a;
+        const occurence = (_a = this.seen.get(baseNameString(entry.name))) !== null && _a !== void 0 ? _a : 0;
+        if (occurence > 1 && !isIrNamespace(entry)) {
+            console.log(`FILTERED (MULTIPLE) ${entry.name}`);
+            this.seen.set(baseNameString(entry.name), occurence - 1);
+            return undefined;
+        }
+        return entry;
     }
 }
 
@@ -9595,18 +10079,9 @@ class MultipleDeclarationFilterTransformer {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-class ParameterTransformer {
+class ParameterTransformer extends Transformer {
     constructor(file) {
-        this.file = file;
-    }
-    transformed() {
-        return createFile(this.file.entries
-            .map(it => {
-            if (isInterface$1(it)) {
-                return this.transformInterface(it);
-            }
-            return it;
-        }));
+        super(file);
     }
     transformInterface(node) {
         return createUpdatedInterface(node, node.methods.map(it => this.transformMethod(it, node)));
@@ -9645,15 +10120,15 @@ class ParameterTransformer {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-class TwinMergeTransformer {
+class TwinMergeTransformer extends Transformer {
     constructor(file) {
-        this.file = file;
-        const all = file.entries.filter(isInterface$1);
+        super(file);
+        const all = linearizeNamespaceMembers(file.entries).filter(isInterface$1);
         this.twins = new Set();
         all
             .filter(it => this.hasPrefix(it.name))
             .forEach(it => {
-            const twin = all.find(candidate => this.withPrefix(candidate.name) === it.name);
+            const twin = all.find(candidate => this.withPrefix(baseNameString(candidate.name)) === it.name);
             if (twin === undefined)
                 return;
             if (!isIrNamespace(twin))
@@ -9662,26 +10137,20 @@ class TwinMergeTransformer {
         });
     }
     hasTwin(name) {
+        name = baseNameString(name);
         if (this.hasPrefix(name)) {
             return this.twins.has(this.withoutPrefix(name));
         }
         return this.twins.has(name);
     }
-    transformed() {
-        return createFile(this.file.entries
-            .map(it => {
-            if (isInterface$1(it)) {
-                return this.transformInterface(it);
-            }
-            return it;
-        })
-            .filter(isDefined));
-    }
     transformInterface(node) {
+        if (node.name === Config.astNodeCommonAncestor) { // TODO: is handwritten
+            return createUpdatedInterface(node, node.methods.map(it => this.transformMethod(it)));
+        }
         if (this.hasTwin(node.name) && this.hasPrefix(node.name)) {
             return undefined;
         }
-        if (this.hasTwin(node.name) && node.name !== Config.astNodeCommonAncestor) { // TODO: is handwritten
+        if (this.hasTwin(node.name) || this.hasPrefix(node.name)) {
             return createUpdatedInterface(node, node.methods.map(it => this.transformMethod(it)), this.withoutPrefix(node.name), [createReferenceType(Config.defaultAncestor)]);
         }
         return createUpdatedInterface(node, node.methods.map(it => this.transformMethod(it)));
@@ -9732,16 +10201,23 @@ class TwinMergeTransformer {
  * limitations under the License.
  */
 class AstNodeFilterTransformer extends BaseInterfaceFilterTransformer {
+    constructor(idl) {
+        super(idl, true);
+    }
     shouldFilterOutInterface(name) {
         if (this.typechecker.isHeir(name, Config.astNodeCommonAncestor))
             return false;
         if (this.typechecker.isHeir(name, Config.defaultAncestor))
             return false;
+        console.log(`FILTERED (AST) ${name}`);
         return true;
     }
     shouldFilterOutMethod(node, name) {
         return false;
     }
+    shouldFilterOutProperty(node, name) {
+        return false;
+    }
 }
 
 /*
@@ -9758,21 +10234,12 @@ class AstNodeFilterTransformer extends BaseInterfaceFilterTransformer {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-class NullabilityTransformer {
+class NullabilityTransformer extends Transformer {
     constructor(file, config) {
-        this.file = file;
+        super(file);
         this.config = config;
         this.typechecker = new Typechecker(this.file.entries);
     }
-    transformed() {
-        return createFile(this.file.entries
-            .map(it => {
-            if (isInterface$1(it)) {
-                return this.transformInterface(it);
-            }
-            return it;
-        }));
-    }
     transformInterface(node) {
         return createUpdatedInterface(node, node.methods
             .map(it => createUpdatedMethod(it, undefined, this.transformedParameters(it, node), this.transformedReturnType(it, node))));
@@ -9783,7 +10250,7 @@ class NullabilityTransformer {
             : this.transformType(it.type)));
     }
     transformedReturnType(node, parent) {
-        if (Config.isCreateOrUpdate(node.name)) {
+        if (isCreateOrUpdate(node.name)) {
             return node.returnType;
         }
         if (this.config.nonNullable.isNonNullableReturnType(parent.name, node.name)) {
@@ -9835,9 +10302,9 @@ function remove(array, value) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-class AttributeTransformer {
+class AttributeTransformer extends Transformer {
     constructor(file) {
-        this.file = file;
+        super(file);
         this.convertor = new LibraryTypeConvertor(new Typechecker(this.file.entries));
     }
     convertToKey(type) {
@@ -9846,18 +10313,9 @@ class AttributeTransformer {
         }
         return this.convertor.convertType(type);
     }
-    transformed() {
-        return createFile(this.file.entries
-            .map(it => {
-            if (isInterface$1(it)) {
-                return this.transformInterface(it);
-            }
-            return it;
-        }));
-    }
     transformInterface(node) {
         var _a;
-        const creates = node.methods.filter(it => Config.isCreate(it.name));
+        const creates = node.methods.filter(it => isCreate(it.name));
         if (creates.length !== 1) {
             return node;
         }
@@ -9913,22 +10371,13 @@ class AttributeTransformer {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-class InteropTransformer {
-    constructor(file) {
-        this.file = file;
-    }
-    transformed() {
-        return createFile(this.file.entries
-            .map(it => {
-            if (isInterface$1(it)) {
-                return this.transformInterface(it);
-            }
-            return it;
-        }), this.file.fileName);
+class InteropTransformer extends Transformer {
+    constructor(config, file) {
+        super(file);
+        this.config = config;
     }
     transformInterface(node) {
-        node = this.withTransformedMethods(node);
-        return node;
+        return this.withTransformedMethods(node);
     }
     withTransformedMethods(node) {
         return createUpdatedInterface(node, node.methods.map(it => this.transformMethod(it, node)));
@@ -9948,7 +10397,7 @@ class InteropTransformer {
         ]);
     }
     withInsertedReceiver(node, parent) {
-        if (Config.isCreateOrUpdate(node.name)) {
+        if (isCreateOrUpdate(node.name)) {
             return node;
         }
         return createUpdatedMethod(node, node.name, [
@@ -9990,25 +10439,17 @@ class InteropTransformer {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-class ConstMergeTransformer {
+class ConstMergeTransformer extends Transformer {
     constructor(file) {
-        this.file = file;
-    }
-    transformed() {
-        return createFile(this.file.entries
-            .map(it => {
-            if (isInterface$1(it)) {
-                return this.transformInterface(it);
-            }
-            return it;
-        }));
+        super(file);
     }
     transformInterface(node) {
         return createUpdatedInterface(node, node.methods
             .filter(it => {
-            const constVersion = it.name + Config.constPostfix;
-            const hasConstVersion = node.methods.some(it => it.name === constVersion);
-            return !hasConstVersion;
+            if (!it.name.endsWith(Config.constPostfix))
+                return true;
+            const nonConstVersion = it.name.substring(0, it.name.length - Config.constPostfix.length);
+            return !node.methods.some(it => it.name === nonConstVersion);
         }));
     }
 }
@@ -10027,30 +10468,21 @@ class ConstMergeTransformer {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-class UniversalCreateTransformer {
+class UniversalCreateTransformer extends Transformer {
     constructor(file) {
-        this.file = file;
-    }
-    transformed() {
-        return createFile(this.file.entries
-            .map(it => {
-            if (isInterface$1(it)) {
-                return UniversalCreateTransformer.transformInterface(it);
-            }
-            return it;
-        }));
+        super(file);
     }
-    static transformInterface(node) {
+    transformInterface(node) {
         const universal = UniversalCreateTransformer.universalCreate(node);
         if (universal === undefined) {
             return node;
         }
         return createUpdatedInterface(node, [universal].concat(node.methods
-            .filter(it => !Config.isCreate(it.name))));
+            .filter(it => !isCreate(it.name))));
     }
     static universalCreate(node) {
         const creates = node.methods
-            .filter(it => Config.isCreate(it.name))
+            .filter(it => isCreate(it.name))
             .filter(it => !UniversalCreateTransformer.isCopyConstructor(it));
         return creates.find(candidate => creates.every(it => UniversalCreateTransformer.isCovered(it, candidate)));
     }
@@ -10103,11 +10535,11 @@ class DynamicEmitter {
         this.shouldLog = shouldLog;
         this.logDir = `./out/log-idl`;
         this.logCount = 0;
-        this.bridgesPrinter = new SingleFileEmitter((idl) => new BridgesPrinter(idl).print(), `libarkts/native/src/generated/bridges.cc`, `bridges.cc`, true);
+        this.bridgesPrinter = new SingleFileEmitter((idl) => new BridgesPrinter(this.config, idl).print(), `libarkts/native/src/generated/bridges.cc`, `bridges.cc`, true);
         this.bindingsPrinter = new SingleFileEmitter((idl) => new BindingsPrinter(idl).print(), `libarkts/src/generated/Es2pandaNativeModule.ts`, `Es2pandaNativeModule.ts`, true);
-        this.enumsPrinter = new SingleFileEmitter((idl) => new EnumsPrinter(idl).print(), `libarkts/src/Es2pandaEnums.ts`, `Es2pandaEnums.ts`, false);
+        this.enumsPrinter = new SingleFileEmitter((idl) => new EnumsPrinter(idl).print(), `libarkts/src/generated/Es2pandaEnums.ts`, `Es2pandaEnums.ts`, true);
         this.indexPrinter = new SingleFileEmitter((idl) => new IndexPrinter(idl).print(), `libarkts/src/generated/index.ts`, `index.ts`, true);
-        this.peersPrinter = new MultiFileEmitter((idl) => new AllPeersPrinter(idl).print(), `libarkts/src/generated/peers`, `peer.ts`, true);
+        this.peersPrinter = new MultiFileEmitter((idl) => new AllPeersPrinter(this.config, idl).print(), `libarkts/src/generated/peers`, `peer.ts`, true);
         this.factoryPrinter = new SingleFileEmitter((idl) => new FactoryPrinter(idl).print(), `libarkts/src/generated/factory.ts`, `factory.ts`, true);
     }
     emit() {
@@ -10136,7 +10568,7 @@ class DynamicEmitter {
         this.printFile(this.factoryPrinter, idl);
     }
     printInterop(idl) {
-        idl = this.withLog(new InteropTransformer(idl));
+        idl = this.withLog(new InteropTransformer(this.config, idl));
         this.printFile(this.bindingsPrinter, idl);
         this.printFile(this.bridgesPrinter, idl);
     }
@@ -11622,77 +12054,41 @@ var lib = JSON5;
  */
 class IgnoreOptions {
     constructor(filePath) {
-        var _a, _b, _c, _d;
+        var _a, _b;
+        this.full = [];
+        this.partial = [];
         if (filePath === undefined) {
-            this.generateByDefault = true;
-            this.interfaces = [];
             return;
         }
-        const json = lib.parse(fs__namespace$1.readFileSync(filePath).toString());
-        if ((json === null || json === void 0 ? void 0 : json.ignore) !== undefined) {
-            this.generateByDefault = true;
-        }
-        else if ((json === null || json === void 0 ? void 0 : json.generate) !== undefined) {
-            this.generateByDefault = false;
-        }
-        else {
-            throwException(`missing options.json section generate or ignore`);
-        }
-        const interfaces = (_d = (_b = (_a = json.ignore) === null || _a === void 0 ? void 0 : _a.interfaces) !== null && _b !== void 0 ? _b : (_c = json.generate) === null || _c === void 0 ? void 0 : _c.interfaces) !== null && _d !== void 0 ? _d : throwException(`missing options.json section generate.interfaces or ignore.interfaces`);
-        this.interfaces = [
-            ...Object.entries(interfaces).map(([name, methods]) => {
-                if (Interface.isWhole(methods)) {
-                    return this.generateByDefault
-                        ? new Ignored(name)
-                        : new Full(name);
-                }
-                return new Partial(name, new Map(Object.values(methods)
-                    .map((name) => [name, !this.generateByDefault])));
-            })
-        ];
+        const ignore = lib.parse(fs__namespace$1.readFileSync(filePath).toString()).ignore;
+        this.full = (_a = ignore === null || ignore === void 0 ? void 0 : ignore.full) !== null && _a !== void 0 ? _a : [];
+        this.partial = (_b = ignore === null || ignore === void 0 ? void 0 : ignore.partial) !== null && _b !== void 0 ? _b : [];
     }
-    shouldEmitMethod(iface, method) {
+    isIgnoredMethod(iface, method) {
         var _a;
-        const known = this.interfaces.find(it => it.name === iface);
-        if (known === undefined) {
-            return this.generateByDefault;
-        }
-        if (known instanceof Ignored) {
-            return false;
-        }
-        if (known instanceof Full) {
-            return true;
-        }
-        if (known instanceof Partial) {
-            return (_a = known.methods.get(method)) !== null && _a !== void 0 ? _a : this.generateByDefault;
-        }
-        throwException(`unexpected kind of interface: ${known}`);
-    }
-    shouldEmitInterface(name) {
-        const known = this.interfaces.find(it => it.name === name);
-        if (known === undefined) {
-            return this.generateByDefault;
-        }
-        return !(known instanceof Ignored);
+        return (_a = this.partial) === null || _a === void 0 ? void 0 : _a.some(it => { var _a; return it.interface === iface && ((_a = it.methods) === null || _a === void 0 ? void 0 : _a.includes(method)); });
     }
-}
-class Interface {
-    constructor(name) {
-        this.name = name;
+    isIgnoredProperty(iface, name) {
+        var _a;
+        return (_a = this.partial) === null || _a === void 0 ? void 0 : _a.some(it => { var _a; return it.interface === iface && ((_a = it.properties) === null || _a === void 0 ? void 0 : _a.includes(name)); });
     }
-    static isWhole(methods) {
-        return methods.includes("*");
+    isIgnoredInterface(name) {
+        return this.full.includes(name);
     }
 }
-class Ignored extends Interface {
-}
-class Full extends Interface {
-}
-class Partial extends Interface {
-    constructor(name, methods) {
-        super(name);
-        this.name = name;
-        this.methods = methods;
+// TODO: remove when interfaces fixed!
+class IrHackOptions {
+    constructor(filePath) {
+        var _a;
+        this.irHack = [];
+        if (filePath === undefined) {
+            return;
+        }
+        const json = lib.parse(fs__namespace$1.readFileSync(filePath).toString());
+        this.irHack = (_a = json === null || json === void 0 ? void 0 : json.irHack) !== null && _a !== void 0 ? _a : [];
+    }
+    isIrHackInterface(name) {
+        return this.irHack.includes(name);
     }
 }
 
@@ -11789,7 +12185,7 @@ function cliOptions() {
     return {
         pandaSdkPath: (_a = cliOptions.pandaSdkPath) !== null && _a !== void 0 ? _a : throwException(`panda-sdk-path is mandatory parameter`),
         outputDir: (_b = cliOptions.outputDir) !== null && _b !== void 0 ? _b : throwException(`output-dir is mandatory parameter`),
-        optionsFile: (_c = cliOptions.optionsFile) !== null && _c !== void 0 ? _c : throwException(`options-file is mandatory parameter`),
+        optionsFile: (_c = cliOptions.optionsFile) !== null && _c !== void 0 ? _c : path$1.join(__dirname, `../build/libarkts-copy/generator/options.json5`),
         debug: (_d = cliOptions.debug) !== null && _d !== void 0 ? _d : false,
         initialize: (_e = cliOptions.initialize) !== null && _e !== void 0 ? _e : false
     };
@@ -11852,7 +12248,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)), new Config(new IgnoreOptions(options.optionsFile), new NonNullableOptions(options.optionsFile)), options.debug).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();
 }
 main();
 //# sourceMappingURL=index.js.map