@idlizer/arktscgen 2.1.7 → 2.1.9-arktscgen-4

package/lib/index.js

@@ -136,7 +136,7 @@ function error(
         : 1;
 
   const precedingLastLine = lastLine(
-    tokensToText(sliceTokens(-5), { precedes: true }),
+    tokensToText(sliceTokens(-maxTokens), { precedes: true }),
   );
 
   const subsequentTokens = sliceTokens(maxTokens);
@@ -3658,6 +3658,8 @@ class Language {
             case "java": return Language.JAVA;
             case "ts": return Language.TS;
             case "cangjie": return Language.CJ;
+            case "cpp": return Language.CPP;
+            case "kotlin": return Language.KOTLIN;
             default: throw new Error(`Unsupported language ${name}`);
         }
     }
@@ -3667,6 +3669,7 @@ Language.ARKTS = new Language("ArkTS", ".ts", true); // using .ts for ArkTS unti
 Language.JAVA = new Language("Java", ".java", false);
 Language.CPP = new Language("C++", ".cc", false);
 Language.CJ = new Language("CangJie", ".cj", false);
+Language.KOTLIN = new Language("Kotlin", ".kt", false);
 
 /*
  * Copyright (c) 2024 Huawei Device Co., Ltd.
@@ -3830,10 +3833,12 @@ var IDLExtendedAttributes;
     IDLExtendedAttributes["Protected"] = "Protected";
     IDLExtendedAttributes["Synthetic"] = "Synthetic";
     IDLExtendedAttributes["Throws"] = "Throws";
+    IDLExtendedAttributes["TraceKey"] = "TraceKey";
     IDLExtendedAttributes["TypeArguments"] = "TypeArguments";
     IDLExtendedAttributes["TypeParameters"] = "TypeParameters";
     IDLExtendedAttributes["VerbatimDts"] = "VerbatimDts";
     IDLExtendedAttributes["HandWrittenImplementation"] = "HandWrittenImplementation";
+    IDLExtendedAttributes["ExtraMethod"] = "ExtraMethod";
 })(IDLExtendedAttributes || (IDLExtendedAttributes = {}));
 var IDLAccessorAttribute;
 (function (IDLAccessorAttribute) {
@@ -3850,6 +3855,7 @@ var IDLInterfaceSubkind;
 })(IDLInterfaceSubkind || (IDLInterfaceSubkind = {}));
 /** Updates tree in place! */
 function updateEachChild(node, op, cbLeave) {
+    var _a;
     const old = node;
     node = op(old);
     if (node.kind !== old.kind) {
@@ -3932,7 +3938,11 @@ function updateEachChild(node, op, cbLeave) {
             concrete.typeArguments = concrete.typeArguments.map(it => updateEachChild(it, op, cbLeave));
             break;
         }
-        case IDLKind.ReferenceType:
+        case IDLKind.ReferenceType: {
+            const concrete = node;
+            concrete.typeArguments = (_a = concrete.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => updateEachChild(it, op, cbLeave));
+            break;
+        }
         case IDLKind.TypeParameterType:
         case IDLKind.EnumMember:
         case IDLKind.Import:
@@ -4041,15 +4051,6 @@ function createOptionalType(element, nodeInitializer) {
     }
     return Object.assign(Object.assign({ kind: IDLKind.OptionalType, type: element }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlTypeBrand: innerIdlSymbol });
 }
-/**
- * This placeholder is used when a class has no superclass.
- * Examples:
- *  class definition:               inheritance:
- * `C extends T`                  :  [T]
- * `C implements T`               :  [Top, T]
- * `C extends T implements I, J`  :  [T, I, J]
- */
-const IDLTopType = createReferenceType("__TOP__");
 // must match with toIDLType in deserialize.ts
 const IDLPointerType = createPrimitiveType('pointer');
 const IDLVoidType = createPrimitiveType('void');
@@ -4084,15 +4085,10 @@ createPrimitiveType('InteropReturnBuffer');
 function createNamespace(name, members, nodeInitializer) {
     return Object.assign(Object.assign({ kind: IDLKind.Namespace, members: members !== null && members !== void 0 ? members : [], name: name }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
 }
-function isSpecialNodes(node) {
-    return node === IDLTopType
-        || node === IDLObjectType
-        || isPrimitiveType(node);
-}
 function linkParentBack(node) {
     const parentStack = [];
     updateEachChild(node, (node) => {
-        if (isSpecialNodes(node)) {
+        if (isPrimitiveType(node)) {
             return node;
         }
         if (parentStack.length) {
@@ -4105,7 +4101,7 @@ function linkParentBack(node) {
         parentStack.push(node);
         return node;
     }, (node) => {
-        if (isSpecialNodes(node)) {
+        if (isPrimitiveType(node)) {
             return;
         }
         parentStack.pop();
@@ -4483,7 +4479,10 @@ function printParameters(parameters) {
     return (_b = (_a = parameters === null || parameters === void 0 ? void 0 : parameters.map(it => nameWithType(it, it.isVariadic, it.isOptional))) === null || _a === void 0 ? void 0 : _a.join(", ")) !== null && _b !== void 0 ? _b : "";
 }
 function printConstructor(idl) {
-    return [`constructor(${printParameters(idl.parameters)});`];
+    return [
+        ...printExtendedAttributes(idl),
+        `constructor(${printParameters(idl.parameters)});`
+    ];
 }
 function nameWithType(idl, isVariadic = false, isOptional = false) {
     const type = printType(idl.type);
@@ -4549,6 +4548,7 @@ const attributesToQuote = new Set([
     IDLExtendedAttributes.DtsTag,
     IDLExtendedAttributes.Import,
     IDLExtendedAttributes.Interfaces,
+    IDLExtendedAttributes.TraceKey,
     IDLExtendedAttributes.TypeArguments,
     IDLExtendedAttributes.TypeParameters,
 ]);
@@ -4618,28 +4618,10 @@ function printCallback(idl) {
     ];
 }
 function printInterfaceInherit(idl) {
-    var _a;
     if (idl.inheritance.length === 0) {
         return "";
     }
-    const inheritance = [...idl.inheritance];
-    const types = [];
-    if (idl.subkind === IDLInterfaceSubkind.Class) {
-        if (inheritance[0] !== IDLTopType) {
-            const ref = clone(inheritance[0]);
-            (_a = ref.extendedAttributes) !== null && _a !== void 0 ? _a : (ref.extendedAttributes = []);
-            if (!hasExtAttribute(ref, IDLExtendedAttributes.Extends)) {
-                ref.extendedAttributes = ref.extendedAttributes.concat([
-                    { name: IDLExtendedAttributes.Extends }
-                ]);
-            }
-            types.push(`${printType(ref)}`);
-            inheritance.shift();
-        }
-    }
-    inheritance.forEach(type => {
-        types.push(printType(type));
-    });
+    const types = idl.inheritance.map(type => printType(type));
     return ": " + types.join(', ');
 }
 function printInterface(idl) {
@@ -4768,6 +4750,12 @@ function maybeUnwrapOptionalType(type) {
     }
     return type;
 }
+function maybeOptional(type, optional = false) {
+    if (optional) {
+        return createOptionalType(type);
+    }
+    return type;
+}
 const DebugUtils = {
     debugPrintType: (type) => {
         if (isContainerType(type)) {
@@ -4875,13 +4863,10 @@ function warn(message) {
     console.log(`WARNING: ${message}`);
 }
 function forceWriteFile(filePath, content) {
-    path__namespace.dirname(filePath).split(path__namespace.sep).reduce((last, dir) => {
-        const dirPath = path__namespace.join(last, dir);
-        if (!fs__namespace.existsSync(dirPath)) {
-            fs__namespace.mkdirSync(dirPath);
-        }
-        return dirPath;
-    }, ".");
+    const dirPath = path__namespace.dirname(filePath);
+    if (!fs__namespace.existsSync(dirPath)) {
+        fs__namespace.mkdirSync(dirPath, { recursive: true });
+    }
     fs__namespace.writeFileSync(filePath, content);
 }
 function rightmostIndexOf(array, predicate) {
@@ -5221,7 +5206,7 @@ const D = {
                 };
             });
         },
-        null(x) {
+        null() {
             return new ConfigDescriberLeaf(xs => {
                 if (typeof xs === 'object' && xs === null) {
                     return ValidationBox.ok(null);
@@ -5306,7 +5291,8 @@ D.object({
     forceResource: T.stringArray(),
     forceContext: T.stringArray(),
     hooks: D.map(D.string(), D.map(D.string(), HookMethodSchema)).onMerge('replace'),
-    externalModuleTypes: D.map(D.string(), D.string()).onMerge('replace'),
+    externalTypes: D.map(D.string(), D.string()).onMerge('replace'),
+    externalPackages: T.stringArray(),
     moduleName: D.string(),
     modules: D.map(D.string(), ModuleConfigurationSchema).onMerge('replace'),
     globalPackages: T.stringArray()
@@ -5325,7 +5311,8 @@ const defaultCoreConfiguration = {
     forceResource: [],
     forceContext: [],
     hooks: new Map(),
-    externalModuleTypes: new Map(),
+    externalTypes: new Map(),
+    externalPackages: [],
     moduleName: "",
     modules: new Map(),
     globalPackages: []
@@ -5593,6 +5580,7 @@ class IndentedPrinter {
         return this.output;
     }
     printTo(file) {
+        fs__namespace.mkdirSync(path.dirname(file), { recursive: true });
         fs__namespace.writeFileSync(file, this.getOutput().join("\n"));
     }
     withIndent(prints) {
@@ -5701,6 +5689,18 @@ class MethodCallExpression extends FunctionCallExpression {
         return `${this.receiver}${this.nullable ? "?" : ""}.${super.asString()}`;
     }
 }
+class MethodStaticCallExpression extends MethodCallExpression {
+    constructor(receiver, method, params, nullable = false) {
+        super(receiver, method, params, nullable);
+        this.receiver = receiver;
+        this.nullable = nullable;
+    }
+}
+class ThisCallExpression extends FunctionCallExpression {
+    constructor(params) {
+        super("this", params);
+    }
+}
 class FieldAccessExpression {
     constructor(receiver, field, nullable = false) {
         this.receiver = receiver;
@@ -5903,6 +5903,9 @@ class LambdaExpression {
                 stmt.write(writer);
             }
         }
+        writer.features.forEach(([feature, module]) => {
+            this.originalWriter.addFeature(feature, module);
+        });
         return (this.body ? ((_a = this.body) === null || _a === void 0 ? void 0 : _a.length) > 1 ? '\n' : '' : '').concat(writer.getOutput()
             .filter(line => line !== "")
             .map(line => indentedBy(line.endsWith('{') || line.endsWith('}') || line.endsWith(';') ? line : `${line};`, 1))
@@ -5940,6 +5943,7 @@ var MethodModifier;
     MethodModifier[MethodModifier["THROWS"] = 8] = "THROWS";
     MethodModifier[MethodModifier["FREE"] = 9] = "FREE";
     MethodModifier[MethodModifier["FORCE_CONTEXT"] = 10] = "FORCE_CONTEXT";
+    MethodModifier[MethodModifier["OVERRIDE"] = 11] = "OVERRIDE";
 })(MethodModifier || (MethodModifier = {}));
 var ClassModifier;
 (function (ClassModifier) {
@@ -5947,6 +5951,11 @@ var ClassModifier;
     ClassModifier[ClassModifier["PRIVATE"] = 1] = "PRIVATE";
     ClassModifier[ClassModifier["PROTECTED"] = 2] = "PROTECTED";
 })(ClassModifier || (ClassModifier = {}));
+var DelegationType;
+(function (DelegationType) {
+    DelegationType[DelegationType["THIS"] = 0] = "THIS";
+    DelegationType[DelegationType["SUPER"] = 1] = "SUPER";
+})(DelegationType || (DelegationType = {}));
 class Method {
     constructor(name, signature, modifiers = undefined, generics) {
         this.name = name;
@@ -5968,6 +5977,7 @@ PrintHint.AsPointer = new PrintHint('AsPointer');
 PrintHint.AsConstPointer = new PrintHint('AsConstPointer');
 PrintHint.AsValue = new PrintHint('AsValue');
 PrintHint.AsConstReference = new PrintHint('AsConstReference');
+PrintHint.AsReference = new PrintHint('AsReference');
 class MethodSignature {
     constructor(returnType, args, defaults = undefined, argsModifiers = undefined, printHints, argNames) {
         this.returnType = returnType;
@@ -6023,11 +6033,15 @@ class LanguageWriter {
         this.resolver = resolver;
         this.language = language;
         this.namespaceStack = [];
+        this.features = [];
     }
     indentDepth() {
         return this.printer.indentDepth();
     }
     maybeSemicolon() { return ";"; }
+    addFeature(feature, module) {
+        this.features.push([feature, module]);
+    }
     // version of makeCast which uses TypeCheck.typeCast<T>(value) call for ETS language writer
     // Use it only if TypeChecker class is added as import to the generated file
     makeTypeCast(value, type, options) {
@@ -6054,12 +6068,17 @@ class LanguageWriter {
         var _a;
         this.writeMethodImplementation(new Method(method.name, method.signature, [MethodModifier.SETTER].concat((_a = method.modifiers) !== null && _a !== void 0 ? _a : [])), op);
     }
+    // Deprecated
+    // Use instead declarationCall parameter in writeConstructorImplementation(...)
     writeSuperCall(params) {
         this.printer.print(`super(${params.join(", ")})${this.maybeSemicolon()}`);
     }
     writeMethodCall(receiver, method, params, nullable = false) {
         this.printer.print(`${receiver}${nullable ? "?" : ""}.${method}(${params.join(", ")})`);
     }
+    writeStaticMethodCall(receiver, method, params, nullable = false) {
+        this.writeMethodCall(receiver, method, params, nullable);
+    }
     writeStatement(stmt) {
         stmt.write(this);
     }
@@ -6110,6 +6129,14 @@ class LanguageWriter {
     makeMethodCall(receiver, method, params, nullable) {
         return new MethodCallExpression(receiver, method, params, nullable);
     }
+    // Deprecated
+    // Use instead declarationCall parameter in writeConstructorImplementation(...) with DelegationType.THIS
+    makeThisCall(params) {
+        return new ThisCallExpression(params);
+    }
+    makeStaticMethodCall(receiver, method, params, nullable) {
+        return new MethodStaticCallExpression(receiver, method, params, nullable);
+    }
     makeFieldAccess(receiver, method, nullable) {
         return new FieldAccessExpression(receiver, method, nullable);
     }
@@ -6291,6 +6318,9 @@ class LanguageWriter {
     makeCallIsObject(value) {
         return this.makeString(`typeof ${value} === "object"`);
     }
+    makeStaticBlock(op) {
+        op(this);
+    }
     instanceOf(convertor, value, _duplicateMembers) {
         return this.makeString(`${value} instanceof ${this.getNodeName(convertor.idlType)}`);
     }
@@ -6647,6 +6677,11 @@ class CppPointerPropertyAccessExpression {
         return `${this.expression}->${this.name}`;
     }
 }
+class CPPMethodStaticCallExpression extends MethodStaticCallExpression {
+    asString() {
+        return `${this.receiver}::${this.name}(${this.params.map(it => it.asString()).join(', ')})`;
+    }
+}
 ////////////////////////////////////////////////////////////////
 //                         STATEMENTS                         //
 ////////////////////////////////////////////////////////////////
@@ -6743,8 +6778,13 @@ class CppLanguageWriter extends CLikeLanguageWriter {
     constructor(printer, resolver, typeConvertor, primitivesTypes) {
         super(printer, resolver, Language.CPP);
         this.primitivesTypes = primitivesTypes;
+        this.classMode = 'normal';
+        this.currentClass = [];
         this.typeConvertor = typeConvertor;
     }
+    changeModeTo(mode) {
+        this.classMode = mode;
+    }
     getNodeName(type) {
         return this.typeConvertor.convert(type);
     }
@@ -6752,14 +6792,28 @@ class CppLanguageWriter extends CLikeLanguageWriter {
         var _a;
         return new CppLanguageWriter(new IndentedPrinter(), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.primitivesTypes);
     }
+    writeDeclaration(name, signature, modifiers, postfix) {
+        const realName = this.classMode === 'normal' ? name : `${this.currentClass.at(0)}::${name}`;
+        const newModifiers = this.classMode === 'normal'
+            ? modifiers
+            : (modifiers !== null && modifiers !== void 0 ? modifiers : []).filter(it => it !== MethodModifier.STATIC).concat(MethodModifier.INLINE);
+        super.writeDeclaration(realName, signature, newModifiers, postfix);
+    }
     writeClass(name, op, superClass, interfaces) {
-        const superClasses = (superClass ? [superClass] : []).concat(interfaces !== null && interfaces !== void 0 ? interfaces : []);
-        const extendsClause = superClasses.length > 0 ? ` : ${superClasses.map(c => `public ${c}`).join(", ")}` : '';
-        this.printer.print(`class ${name}${extendsClause} {`);
-        this.pushIndent();
+        if (this.classMode === 'normal') {
+            const superClasses = (superClass ? [superClass] : []).concat(interfaces !== null && interfaces !== void 0 ? interfaces : []);
+            const extendsClause = superClasses.length > 0 ? ` : ${superClasses.map(c => `public ${c}`).join(", ")}` : '';
+            this.printer.print(`class ${name}${extendsClause} {`);
+            this.pushIndent();
+        }
+        if (this.classMode === 'detached') {
+            this.currentClass.push(name);
+        }
         op(this);
-        this.popIndent();
-        this.printer.print(`};`);
+        if (this.classMode === 'normal') {
+            this.popIndent();
+            this.printer.print(`};`);
+        }
     }
     writeInterface(name, op, superInterfaces, generics) {
         throw new Error("Method not implemented.");
@@ -6772,6 +6826,9 @@ class CppLanguageWriter extends CLikeLanguageWriter {
             super.writeMethodCall(receiver, method, params, nullable);
         }
     }
+    writeStaticMethodCall(receiver, method, params, nullable) {
+        this.printer.print(`${receiver}::${method}(${params.join(', ')});`);
+    }
     writeFieldDeclaration(name, type, modifiers, optional, initExpr) {
         let filter = function (modifier_name) {
             return modifier_name !== FieldModifier.STATIC;
@@ -6782,9 +6839,9 @@ class CppLanguageWriter extends CLikeLanguageWriter {
         this.printer.print(`${forceAsNamedNode(type).name} ${name};`);
         this.printer.popIndent();
     }
-    writeConstructorImplementation(className, signature, op, superCall, modifiers) {
-        const superInvocation = superCall
-            ? ` : ${superCall.name}(${superCall.signature.args.map((_, i) => superCall === null || superCall === void 0 ? void 0 : superCall.signature.argName(i)).join(", ")})`
+    writeConstructorImplementation(className, signature, op, delegationCall, modifiers) {
+        const superInvocation = delegationCall
+            ? ` : ${delegationCall.delegationName}(${delegationCall.delegationArgs.map(it => it.asString()).join(", ")})`
             : "";
         const argList = signature.args.map((it, index) => {
             var _a;
@@ -6874,6 +6931,9 @@ class CppLanguageWriter extends CLikeLanguageWriter {
     makeUnionVariantCast(value, type, convertor, index) {
         return this.makeString(`${value}.value${index}`);
     }
+    makeStaticMethodCall(receiver, method, params, nullable) {
+        return new CPPMethodStaticCallExpression(receiver, method, params, nullable);
+    }
     makeLoop(counter, limit, statement) {
         return new CLikeLoopStatement(counter, limit, statement);
     }
@@ -7014,6 +7074,9 @@ class CppLanguageWriter extends CLikeLanguageWriter {
             case PrintHint.AsPointer:
                 postfix = '*';
                 break;
+            case PrintHint.AsReference:
+                postfix = '&';
+                break;
             case PrintHint.AsConstPointer:
                 constModifier = 'const ';
                 postfix = '*';
@@ -7265,11 +7328,13 @@ class TSLanguageWriter extends LanguageWriter {
     writeMethodDeclaration(name, signature, modifiers) {
         this.writeDeclaration(name, signature, true, false, modifiers);
     }
-    writeConstructorImplementation(className, signature, op, superCall, modifiers) {
+    writeConstructorImplementation(className, signature, op, delegationCall, modifiers) {
+        var _a;
         this.writeDeclaration(`${modifiers ? modifiers.map((it) => MethodModifier[it].toLowerCase()).join(' ') + ' ' : ''}constructor`, signature, false, true);
         this.pushIndent();
-        if (superCall) {
-            this.print(`super(${superCall.signature.args.map((_, i) => superCall === null || superCall === void 0 ? void 0 : superCall.signature.argName(i)).join(", ")})`);
+        if (delegationCall) {
+            const delegationType = ((delegationCall === null || delegationCall === void 0 ? void 0 : delegationCall.delegationType) == DelegationType.THIS) ? "this" : "super";
+            this.print(`${delegationType}(${(_a = delegationCall.delegationArgs) === null || _a === void 0 ? void 0 : _a.map(it => it.asString()).join(", ")})`);
         }
         op(this);
         this.popIndent();
@@ -7557,6 +7622,12 @@ class CJFeatureNameConvertor extends DeclarationNameConvertor {
     }
 }
 CJFeatureNameConvertor.I = new CJFeatureNameConvertor();
+class KotlinFeatureNameConvertor extends DeclarationNameConvertor {
+    convertEnum(decl) {
+        return decl.name;
+    }
+}
+KotlinFeatureNameConvertor.I = new KotlinFeatureNameConvertor();
 function createDeclarationNameConvertor(language) {
     switch (language) {
         case Language.ARKTS: return ETSDeclarationNameConvertor.I;
@@ -7691,15 +7762,15 @@ class ETSLambdaExpression extends LambdaExpression {
 function generateTypeCheckerName(typeName) {
     typeName = typeName
         .replaceAll('[]', 'BracketsArray')
-        .split('.').at(-1); // Todo: hack for namespaces. Remove when ready to use FQNames
+        .split('.').join('_');
     return `is${typeName.replaceAll('[]', 'Brackets')}`;
 }
-function generateEnumToNumericName(typeName) {
-    typeName = typeName.split('.').at(-1); // Todo: hack for namespaces. Remove when ready to use FQNames
+function generateEnumToNumericName(entry) {
+    const typeName = getQualifiedName(entry, "namespace.name").split('.').join('_');
     return `${typeName}_ToNumeric`;
 }
-function generateEnumFromNumericName(typeName) {
-    typeName = typeName.split('.').at(-1); // Todo: hack for namespaces. Remove when ready to use FQNames
+function generateEnumFromNumericName(entry) {
+    const typeName = getQualifiedName(entry, "namespace.name").split('.').join('_');
     return `${typeName}_FromNumeric`;
 }
 function makeArrayTypeCheckCall(valueAccessor, typeName, writer) {
@@ -7728,7 +7799,7 @@ class ETSLanguageWriter extends TSLanguageWriter {
         return new ArkTSMapForEachStatement(map, key, value, op);
     }
     makeMapSize(map) {
-        return this.makeString(`${super.makeMapSize(map).asString()} as int32`); // TODO: cast really needed?
+        return this.makeString(`${super.makeMapSize(map).asString()}`); // TODO: cast really needed?
     }
     get supportedModifiers() {
         return [MethodModifier.PUBLIC, MethodModifier.PRIVATE, MethodModifier.NATIVE, MethodModifier.STATIC];
@@ -7741,8 +7812,7 @@ class ETSLanguageWriter extends TSLanguageWriter {
     }
     i32FromEnum(value, enumEntry) {
         if (ETSLanguageWriter.isUseTypeChecker) {
-            const enumName = this.getNodeName(enumEntry);
-            return this.makeMethodCall('TypeChecker', generateEnumToNumericName(enumName), [value]);
+            return this.makeMethodCall('TypeChecker', generateEnumToNumericName(enumEntry), [value]);
         }
         return isStringEnum(enumEntry)
             ? this.makeMethodCall(value.asString(), 'getOrdinal', [])
@@ -7751,7 +7821,7 @@ class ETSLanguageWriter extends TSLanguageWriter {
     enumFromI32(value, enumEntry) {
         const enumName = this.getNodeName(enumEntry);
         if (ETSLanguageWriter.isUseTypeChecker) {
-            return this.makeMethodCall('TypeChecker', generateEnumFromNumericName(enumName), [value]);
+            return this.makeMethodCall('TypeChecker', generateEnumFromNumericName(enumEntry), [value]);
         }
         return isStringEnum(enumEntry)
             ? this.makeString(`${enumName}.values()[${value.asString()}]`)
@@ -7843,8 +7913,8 @@ class ETSLanguageWriter extends TSLanguageWriter {
         // The explicit cast forces ui2abc to call valueOf on an int, which fails the compilation
         // TODO Fix this cast
         if (bitness === 8)
-            return value;
-        return `${value} as int32`; // FIXME: is there int8 in ARKTS?
+            return `(${value}).toChar()`;
+        return `(${value}).toInt()`; // FIXME: is there int8 in ARKTS?
     }
     castToBoolean(value) { return `${value} ? 1 : 0`; }
     instanceOf(convertor, value, duplicateMembers) {
@@ -7881,6 +7951,16 @@ class ETSLanguageWriter extends TSLanguageWriter {
     }
     makeCast(value, node, options) {
         var _a;
+        if (node === IDLI64Type)
+            return this.makeMethodCall(value.asString(), `toLong`, []);
+        if (node === IDLI32Type)
+            return this.makeMethodCall(value.asString(), `toInt`, []);
+        if (node === IDLI8Type)
+            return this.makeMethodCall(value.asString(), `toByte`, []);
+        if (node === IDLF64Type)
+            return this.makeMethodCall(value.asString(), `toDouble`, []);
+        if (node === IDLF32Type)
+            return this.makeMethodCall(value.asString(), `toFloat`, []);
         return new TSCastExpression(value, `${this.getNodeName(node)}`, (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
     }
     static get isUseTypeChecker() { return this._isUseTypeChecker; }
@@ -7994,6 +8074,32 @@ class UnionRuntimeTypeChecker {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+var LayoutNodeRole;
+(function (LayoutNodeRole) {
+    LayoutNodeRole[LayoutNodeRole["PEER"] = 0] = "PEER";
+    LayoutNodeRole[LayoutNodeRole["INTERFACE"] = 1] = "INTERFACE";
+    LayoutNodeRole[LayoutNodeRole["GLOBAL"] = 2] = "GLOBAL";
+    LayoutNodeRole[LayoutNodeRole["COMPONENT"] = 3] = "COMPONENT";
+    LayoutNodeRole[LayoutNodeRole["SERIALIZER"] = 4] = "SERIALIZER";
+})(LayoutNodeRole || (LayoutNodeRole = {}));
+
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function getSerializerName(declaration) {
+    return `${getQualifiedName(declaration, "namespace.name").split('.').join('_')}_serializer`;
+}
 class BaseArgConvertor {
     constructor(idlType, runtimeTypes, isScoped, useArray, param) {
         this.idlType = idlType;
@@ -8101,7 +8207,7 @@ class AggregateConvertor extends BaseArgConvertor {
     convertorSerialize(param, value, printer) {
         this.memberConvertors.forEach((it, index) => {
             let memberName = this.members[index][0];
-            let memberAccess = `${value}.${memberName}`;
+            let memberAccess = `${value}.${printer.escapeKeyword(memberName)}`;
             printer.writeStatement(printer.makeAssign(`${value}_${memberName}`, undefined, printer.makeString(memberAccess), true));
             it.convertorSerialize(param, `${value}_${memberName}`, printer);
         });
@@ -8127,9 +8233,7 @@ class AggregateConvertor extends BaseArgConvertor {
                 /**
                  * todo: check UnionType name creation for union of unnamed nodes (isNamedNode() == false)
                  */
-                const memberType = prop.isOptional
-                    ? createUnionType([IDLUndefinedType, prop.type])
-                    : prop.type;
+                const memberType = maybeOptional(prop.type, prop.isOptional);
                 return writer.makeAssign(`${bufferName}_${prop.name}`, memberType, expr, true, true);
             }, writer));
         }
@@ -8179,10 +8283,14 @@ class InterfaceConvertor extends BaseArgConvertor {
         throw new Error("Must never be used");
     }
     convertorSerialize(param, value, printer) {
-        printer.writeMethodCall(`${param}Serializer`, `write${this.library.getInteropName(this.idlType)}`, [value]);
+        const accessor = getSerializerName(this.declaration);
+        printer.addFeature(accessor, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
+        printer.writeStaticMethodCall(accessor, 'write', [`${param}Serializer`, value]);
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
-        return assigneer(writer.makeMethodCall(`${deserializerName}`, `read${this.library.getInteropName(this.idlType)}`, []));
+        const accessor = getSerializerName(this.declaration);
+        writer.addFeature(accessor, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
+        return assigneer(writer.makeStaticMethodCall(accessor, 'read', [writer.makeString(deserializerName)]));
     }
     nativeType() {
         return this.idlType;
@@ -8346,13 +8454,13 @@ class OptionConvertor extends BaseArgConvertor {
         const valueType = `${value}_type`.replaceAll('.', '_');
         const serializedType = (printer.language == Language.JAVA ? undefined : IDLI32Type);
         printer.writeStatement(printer.makeAssign(valueType, serializedType, printer.makeRuntimeType(RuntimeType.UNDEFINED), true, false));
-        if (printer.language != Language.CJ) {
+        if (printer.language != Language.CJ && printer.language != Language.KOTLIN) {
             printer.runtimeType(this, valueType, value);
             printer.writeMethodCall(`${param}Serializer`, "writeInt8", [printer.castToInt(valueType, 8)]);
         }
         printer.print(`if (${printer.makeRuntimeTypeCondition(valueType, false, RuntimeType.UNDEFINED, value).asString()}) {`);
         printer.pushIndent();
-        if (printer.language == Language.CJ) {
+        if (printer.language == Language.CJ || printer.language == Language.KOTLIN) {
             printer.writeMethodCall(`${param}Serializer`, "writeInt8", ["RuntimeType.OBJECT.ordinal"]); // everything is object, except None<T>
         }
         const valueValue = `${value}_value`.replaceAll('.', '_');
@@ -8360,7 +8468,7 @@ class OptionConvertor extends BaseArgConvertor {
         this.typeConvertor.convertorSerialize(param, this.typeConvertor.getObjectAccessor(printer.language, valueValue), printer);
         printer.popIndent();
         printer.print(`}`);
-        if (printer.language == Language.CJ) {
+        if (printer.language == Language.CJ || printer.language == Language.KOTLIN) {
             printer.print('else {');
             printer.pushIndent();
             printer.writeMethodCall(`${param}Serializer`, "writeInt8", ["RuntimeType.UNDEFINED.ordinal"]); // undefined
@@ -8376,7 +8484,7 @@ class OptionConvertor extends BaseArgConvertor {
         const statements = [];
         statements.push(writer.makeAssign(runtimeBufferName, undefined, writer.makeCast(writer.makeString(`${deserializerName}.readInt8()`), writer.getRuntimeType()), true));
         const bufferType = this.nativeType();
-        statements.push(writer.makeAssign(bufferName, bufferType, writer.language == Language.CJ ? writer.makeNull() : undefined, true, false));
+        statements.push(writer.makeAssign(bufferName, bufferType, (writer.language == Language.CJ || writer.language == Language.KOTLIN) ? writer.makeNull() : undefined, true, false));
         const thenStatement = new BlockStatement([
             this.typeConvertor.convertorDeserialize(`${bufferName}_`, deserializerName, (expr) => {
                 const receiver = writer.language === Language.CPP
@@ -8446,7 +8554,7 @@ class UnionConvertor extends BaseArgConvertor {
             statements.push(writer.makeAssign(`${bufferName}.selector`, undefined, writer.makeString(selectorBuffer), false));
         const branches = this.memberConvertors.map((it, index) => {
             const receiver = this.getObjectAccessor(writer.language, bufferName, { index: `${index}` });
-            const expr = writer.makeString(`${selectorBuffer} == ${index}`);
+            const expr = writer.makeString(`${selectorBuffer} == ${writer.castToInt(index.toString(), 8)}`);
             const stmt = new BlockStatement([
                 writer.makeSetUnionSelector(bufferName, `${index}`),
                 it.convertorDeserialize(`${bufferName}_u`, deserializerName, (expr) => {
@@ -8507,8 +8615,9 @@ class FunctionConvertor extends BaseArgConvertor {
     }
 }
 class MaterializedClassConvertor extends BaseArgConvertor {
-    constructor(param, declaration) {
+    constructor(library, param, declaration) {
         super(createReferenceType(declaration), [RuntimeType.OBJECT], false, false, param);
+        this.library = library;
         this.declaration = declaration;
     }
     convertorArg(param, writer) {
@@ -8517,18 +8626,20 @@ class MaterializedClassConvertor extends BaseArgConvertor {
                 return `static_cast<${generatorTypePrefix()}${qualifiedName(this.declaration, "_", "namespace.name")}>(${param})`;
             case Language.JAVA:
             case Language.CJ:
-                return `MaterializedBase.toPeerPtr(${param})`;
+                return `MaterializedBase.toPeerPtr(${writer.escapeKeyword(param)})`;
             default:
                 return `toPeerPtr(${param})`;
         }
     }
     convertorSerialize(param, value, printer) {
-        printer.writeStatement(printer.makeStatement(printer.makeMethodCall(`${param}Serializer`, `write${qualifiedName(this.declaration, "_", "namespace.name")}`, [
-            printer.makeString(value)
-        ])));
+        const accessorRoot = getSerializerName(this.declaration);
+        printer.addFeature(accessorRoot, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
+        printer.writeStaticMethodCall(accessorRoot, 'write', [`${param}Serializer`, value]);
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
-        const readStatement = writer.makeCast(writer.makeMethodCall(`${deserializerName}`, `read${qualifiedName(this.declaration, "_", "namespace.name")}`, []), this.declaration);
+        const accessorRoot = getSerializerName(this.declaration);
+        writer.addFeature(accessorRoot, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
+        const readStatement = writer.makeCast(writer.makeStaticMethodCall(accessorRoot, "read", [writer.makeString(deserializerName)]), this.declaration);
         return assigneer(readStatement);
     }
     nativeType() {
@@ -8562,28 +8673,6 @@ function warnCustomObject(type, msg) {
     }
 }
 
-/*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-var LayoutNodeRole;
-(function (LayoutNodeRole) {
-    LayoutNodeRole[LayoutNodeRole["PEER"] = 0] = "PEER";
-    LayoutNodeRole[LayoutNodeRole["INTERFACE"] = 1] = "INTERFACE";
-    LayoutNodeRole[LayoutNodeRole["GLOBAL"] = 2] = "GLOBAL";
-    LayoutNodeRole[LayoutNodeRole["COMPONENT"] = 3] = "COMPONENT";
-})(LayoutNodeRole || (LayoutNodeRole = {}));
-
 function isInModule(nodeOrPackage, module) {
     if (typeof nodeOrPackage === 'object')
         return isInModule(getPackageName(nodeOrPackage), module);
@@ -8661,10 +8750,6 @@ var IDLValidationDiagnosticsCode;
     [IDLValidationDiagnosticsCode.ENUM_IS_NOT_CONSISTENT]: "Enum includes both string and number values",
     [IDLValidationDiagnosticsCode.REFERENCE_IS_NOT_RESOLVED]: "Can not resolve reference",
 });
-[
-    IDLTopType.name,
-    IDLObjectType.name,
-];
 
 /*
  * Copyright (c) 2024 Huawei Device Co., Ltd.
@@ -8872,13 +8957,12 @@ class IDLDeserializer {
     interfaceSubkind(node) {
         var _a, _b;
         const nodeIDLEntity = (_b = (_a = node.extAttrs.find(it => it.name === "Entity")) === null || _a === void 0 ? void 0 : _a.rhs) === null || _b === void 0 ? void 0 : _b.value;
-        if (nodeIDLEntity == IDLEntity.Class)
-            return IDLInterfaceSubkind.Class;
-        if (nodeIDLEntity == IDLEntity.Interface)
-            return IDLInterfaceSubkind.Interface;
-        if (nodeIDLEntity == IDLEntity.Tuple)
-            return IDLInterfaceSubkind.Tuple;
-        return IDLInterfaceSubkind.Interface;
+        switch (nodeIDLEntity) {
+            case IDLEntity.Class: return IDLInterfaceSubkind.Class;
+            case IDLEntity.Literal: return IDLInterfaceSubkind.AnonymousInterface;
+            case IDLEntity.Tuple: return IDLInterfaceSubkind.Tuple;
+            default: return IDLInterfaceSubkind.Interface;
+        }
     }
     toIDLInterface(file, node) {
         const generics = this.extractGenerics(node.extAttrs);
@@ -8889,29 +8973,16 @@ class IDLDeserializer {
                 return [];
             }
             const implementations = [];
-            let extension = undefined;
             node.inheritance.forEach(it => {
                 var _a;
                 const attributes = it.extAttrs;
                 const parentTypeArgs = this.extractTypeArguments(file, attributes !== null && attributes !== void 0 ? attributes : [], IDLExtendedAttributes.TypeArguments);
                 const attrs = (_a = this.toExtendedAttributes(attributes !== null && attributes !== void 0 ? attributes : [])) === null || _a === void 0 ? void 0 : _a.filter(it => it.name !== IDLExtendedAttributes.TypeArguments);
-                const baseClass = attrs === null || attrs === void 0 ? void 0 : attrs.find(it => it.name === IDLExtendedAttributes.Extends);
                 const ref = createReferenceType(it.inheritance, parentTypeArgs, {
                     extendedAttributes: attrs
                 });
-                if (baseClass) {
-                    extension = ref;
-                }
-                else {
-                    implementations.push(ref);
-                }
+                implementations.push(ref);
             });
-            if (subkind === IDLInterfaceSubkind.Class && extension === undefined && this.inheritanceMode === 'multiple') {
-                extension = IDLTopType;
-            }
-            if (extension) {
-                return [extension, ...implementations];
-            }
             return implementations;
         })(), node.members
             .filter(isConstructor)
@@ -9403,10 +9474,11 @@ class BridgesConstructions {
  * limitations under the License.
  */
 class Config {
-    constructor(ignore, nonNullable, irHack) {
+    constructor(ignore, nonNullable, irHack, fragments) {
         this.ignore = ignore;
         this.nonNullable = nonNullable;
         this.irHack = irHack;
+        this.fragments = fragments;
     }
     static get createPrefix() {
         return `Create`;
@@ -9790,6 +9862,11 @@ class Typechecker {
             return true;
         if (this.isHeir(node, Config.defaultAncestor))
             return true;
+        // TODO: fix
+        if (node === "Program")
+            return true;
+        if (node === "ArkTsConfig")
+            return true;
         return false;
     }
     isReferenceTo(type, isTarget) {
@@ -9813,6 +9890,29 @@ class Typechecker {
             .find(it => it.name === Config.nodeTypeAttribute);
         return (_b = (_a = idlEnum === null || idlEnum === void 0 ? void 0 : idlEnum.elements) === null || _a === void 0 ? void 0 : _a.find(it => { var _a; return ((_a = it.initializer) === null || _a === void 0 ? void 0 : _a.toString()) === value; })) === null || _b === void 0 ? void 0 : _b.name;
     }
+    parent(node) {
+        const parentName = parent(node);
+        if (parentName === undefined)
+            return undefined;
+        const decl = this.findRealDeclaration(parentName);
+        if (decl === undefined)
+            return undefined;
+        if (!isInterface$1(decl))
+            return undefined;
+        return decl;
+    }
+    ancestry(node) {
+        let current = node;
+        const res = [];
+        while (true) {
+            res.push(current);
+            const parent = this.parent(current);
+            if (parent === undefined) {
+                return res;
+            }
+            current = parent;
+        }
+    }
 }
 
 /*
@@ -9864,6 +9964,7 @@ class SingleFilePrinter extends AbstractVisitor {
         this.epilogue();
         return [
             (_b = (_a = this.importer) === null || _a === void 0 ? void 0 : _a.getOutput()) !== null && _b !== void 0 ? _b : [],
+            [''],
             this.writer.getOutput()
         ]
             .flat()
@@ -9950,6 +10051,7 @@ class BaseTypeConvertor {
             case IDLStringType: return this.conversions.string(type);
             case IDLVoidType: return this.conversions.void(type);
             case IDLPointerType: return this.conversions.pointer(type);
+            case IDLUndefinedType: return this.conversions.undefined(type);
         }
         throwException(`unsupported primitive type: ${JSON.stringify(type)}`);
     }
@@ -10015,7 +10117,8 @@ let ReturnTypeConvertor$1 = class ReturnTypeConvertor extends BaseTypeConvertor
             f64: (type) => type,
             boolean: (type) => type,
             void: (type) => type,
-            pointer: (type) => type
+            pointer: (type) => type,
+            undefined: (type) => type
         });
     }
 };
@@ -10036,7 +10139,7 @@ let ReturnTypeConvertor$1 = class ReturnTypeConvertor extends BaseTypeConvertor
 */
 class InteropTypeConvertor extends BaseTypeConvertor {
     constructor(typechecker, heirConversions) {
-        super(typechecker, Object.assign({ enum: (type) => `KInt`, reference: (type) => `KNativePointer`, optional: (type) => throwException(`no nullable allowed at interop level`), i8: (type) => `KBoolean`, iu8: (type) => 'KInt', i16: (type) => `KInt`, i32: (type) => `KInt`, iu32: (type) => `KUInt`, i64: (type) => `KLong`, iu64: (type) => `KULong`, f32: (type) => `KFloat`, f64: (type) => `KDouble`, boolean: (type) => `KBoolean`, void: (type) => `void`, pointer: (type) => `KNativePointer` }, heirConversions));
+        super(typechecker, Object.assign({ enum: (type) => `KInt`, reference: (type) => `KNativePointer`, optional: (type) => throwException(`no nullable allowed at interop level`), undefined: (type) => throwException(`no nullable allowed at interop level`), i8: (type) => `KBoolean`, iu8: (type) => 'KInt', i16: (type) => `KInt`, i32: (type) => `KInt`, iu32: (type) => `KUInt`, i64: (type) => `KLong`, iu64: (type) => `KULong`, f32: (type) => `KFloat`, f64: (type) => `KDouble`, boolean: (type) => `KBoolean`, void: (type) => `void`, pointer: (type) => `KNativePointer` }, heirConversions));
     }
 }
 
@@ -10120,7 +10223,8 @@ class CastTypeConvertor extends BaseTypeConvertor {
             string: (type) => BridgesConstructions.stringCast,
             optional: (type) => throwException(`no optional type allowed at interop level conversion`),
             void: (type) => throwException(`no void typed parameters allowed`),
-            pointer: (type) => throwException(`no pointer typed parameters allowed`)
+            pointer: (type) => throwException(`no pointer typed parameters allowed`),
+            undefined: (type) => throwException(`no undefined typed parameters allowed`)
         });
         this.castToTypeConvertor = new CastToTypeConvertor(this.typechecker);
     }
@@ -10149,7 +10253,8 @@ class CastToTypeConvertor extends BaseTypeConvertor {
             optional: (type) => throwException(`no optional type allowed at interop level conversion`),
             string: (type) => "const char*",
             void: (type) => throwException(`no void typed parameters allowed`),
-            pointer: (type) => throwException(`no pointer typed parameters allowed`)
+            pointer: (type) => throwException(`no pointer typed parameters allowed`),
+            undefined: (type) => throwException(`no undefined typed parameters allowed`)
         });
         this.nativeTypeConvertor = new NativeTypeConvertor(this.typechecker);
     }
@@ -10427,7 +10532,8 @@ class ReturnTypeConvertor extends BaseTypeConvertor {
             boolean: (type) => type,
             string: (type) => type,
             void: (type) => type,
-            pointer: (type) => type
+            pointer: (type) => type,
+            undefined: (type) => throwException(`undefined type is not allowed`)
         });
     }
 }
@@ -10594,6 +10700,9 @@ class PeersConstructions {
     static callPeerMethod(iface, method) {
         return `${iface}.${method}`;
     }
+    static brand(iface) {
+        return `brand${capitalize(iface)}`;
+    }
 }
 
 /*
@@ -10642,6 +10751,14 @@ class Importer {
         this.import(it, `../Es2pandaEnums`);
         return it;
     }
+    withReexportImport(it) {
+        if (this.seen.has(it)) {
+            return it;
+        }
+        this.seen.add(it);
+        this.import(it, "../../reexport-for-generated");
+        return it;
+    }
     import(name, from) {
         this.writer.writeExpressionStatement(this.writer.makeString(PeersConstructions.import(name, path__namespace$1.normalize(path__namespace$1.join(this.dir, from)))));
     }
@@ -10678,7 +10795,8 @@ class TopLevelTypeConvertor extends BaseTypeConvertor {
             f64: heirConversions.number,
             void: heirConversions.void,
             boolean: heirConversions.boolean,
-            pointer: heirConversions.pointer
+            pointer: heirConversions.pointer,
+            undefined: heirConversions.undefined
         }));
     }
 }
@@ -10708,7 +10826,8 @@ class LibraryTypeConvertor extends TopLevelTypeConvertor {
             number: (type) => `number`,
             void: (type) => `void`,
             boolean: (type) => `boolean`,
-            pointer: (type) => `KNativePointer`
+            pointer: (type) => `KNativePointer`,
+            undefined: (type) => `undefined`
         });
     }
 }
@@ -10750,7 +10869,8 @@ class ImporterTypeConvertor extends TopLevelTypeConvertor {
             number: (type) => type,
             boolean: (type) => type,
             void: (type) => type,
-            pointer: (type) => type
+            pointer: (type) => type,
+            undefined: (type) => type
         });
         this.importer = importer;
     }
@@ -10790,6 +10910,7 @@ class BindingParameterTypeConvertor extends TopLevelTypeConvertor {
             void: (type) => (parameter) => parameter,
             pointer: (type) => (parameter) => parameter,
             boolean: (type) => (parameter) => parameter,
+            undefined: (type) => (parameter) => parameter
         });
     }
 }
@@ -10832,6 +10953,7 @@ class BindingReturnValueTypeConvertor extends TopLevelTypeConvertor {
             void: plain,
             pointer: plain,
             boolean: plain,
+            undefined: plain
         });
     }
 }
@@ -10866,6 +10988,7 @@ class PeerPrinter extends SingleFilePrinter {
         return node != this.node;
     }
     constructor(config, idl, node) {
+        var _a;
         super(idl);
         this.config = config;
         this.node = node;
@@ -10873,7 +10996,7 @@ class PeerPrinter extends SingleFilePrinter {
         this.importer = new Importer(this.typechecker, `.`, this.node.name);
         this.bindingParameterTypeConvertor = new BindingParameterTypeConvertor(this.typechecker);
         this.bindingReturnValueTypeConvertor = new BindingReturnValueTypeConvertor(this.typechecker);
-        this.parent = parent(this.node); // ?? throwException(`expected peer to have parent: ${this.node.name}`)
+        this.parent = (_a = parent(this.node)) !== null && _a !== void 0 ? _a : Config.defaultAncestor;
         this.writer = new TSLanguageWriter(new IndentedPrinter(), createEmptyReferenceResolver(), { convert: (node) => composedConvertType(new LibraryTypeConvertor(this.typechecker), new ImporterTypeConvertor(this.importer, this.typechecker), node)
         });
     }
@@ -10883,6 +11006,8 @@ class PeerPrinter extends SingleFilePrinter {
     printBody() {
         this.printConstructor();
         this.printMethods();
+        this.printFragment();
+        this.printBrand();
     }
     printConstructor() {
         this.writer.writeConstructorImplementation(this.node.name, new MethodSignature(IDLVoidType, [
@@ -10923,6 +11048,15 @@ class PeerPrinter extends SingleFilePrinter {
             }
         });
     }
+    printFragment() {
+        const methods = this.config.fragments.getCodeFragment(this.node.name);
+        if (methods !== undefined) {
+            methods.forEach(it => {
+                this.importer.withReexportImport(it.definition);
+                this.writer.writeLines(`${it.name} = ${it.definition}`);
+            });
+        }
+    }
     printGetter(node) {
         this.writer.writeMethodImplementation(new Method(peerMethod(node.name), new MethodSignature(flattenType(node.returnType), []), [MethodModifier.GETTER]), () => {
             this.writer.writeStatement(this.writer.makeReturn(this.makeReturnBindingCall(node)));
@@ -10944,9 +11078,13 @@ class PeerPrinter extends SingleFilePrinter {
     }
     printCreateOrUpdate(node) {
         this.writer.writeMethodImplementation(makeMethod(PeersConstructions.createOrUpdate(this.node.name, node.name), node.parameters.map(it => createParameter(it.name, flattenType(it.type))), flattenType(node.returnType), [MethodModifier.STATIC]), () => {
-            this.writer.writeStatement(this.writer.makeReturn(this.writer.makeNewObject(this.node.name, [
+            const newExpr = this.writer.makeNewObject(this.node.name, [
                 this.writer.makeFunctionCall(this.writer.makeString(PeersConstructions.callBinding(this.node.name, node.name, nodeNamespace(this.node))), this.makeBindingArguments(node.parameters))
-            ])));
+            ]);
+            const isAstNode = this.node.inheritance.some(parent => this.typechecker.isHeir(parent.name, Config.astNodeCommonAncestor));
+            const updateMethodName = 'updateChildren';
+            this.writer.writeStatement(this.writer.makeReturn(isAstNode ?
+                this.writer.makeMethodCall(newExpr.asString(), updateMethodName, []) : newExpr));
         });
     }
     makeBindingArguments(parameters) {
@@ -10966,6 +11104,9 @@ class PeerPrinter extends SingleFilePrinter {
         const qualified = `${this.importer.withEnumImport(Config.nodeTypeAttribute)}.${enumValue}`;
         this.writer.writeExpressionStatements(this.writer.makeString(`if (!nodeByType.has(${qualified})) {`), this.writer.makeString(`    nodeByType.set(${qualified}, (peer: KNativePointer) => new ${this.node.name}(peer))`), this.writer.makeString(`}`));
     }
+    printBrand() {
+        this.writer.writeProperty(PeersConstructions.brand(this.node.name), IDLUndefinedType, [FieldModifier.PROTECTED, FieldModifier.READONLY]);
+    }
 }
 
 /*
@@ -11465,6 +11606,11 @@ class AstNodeFilterTransformer extends BaseInterfaceFilterTransformer {
             return false;
         if (this.typechecker.isHeir(name, Config.defaultAncestor))
             return false;
+        // TODO: fix
+        if (name === "Program")
+            return false;
+        if (name === "ArkTsConfig")
+            return false;
         console.log(`FILTERED (AST) ${name}`);
         return true;
     }
@@ -13484,6 +13630,35 @@ class NonNullableOptions {
     }
 }
 
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class CodeFragmentOptions {
+    constructor(filePath) {
+        var _a;
+        this.fragments = [];
+        if (filePath === undefined) {
+            return;
+        }
+        this.fragments = (_a = lib.parse(fs__namespace$1.readFileSync(filePath).toString()).fragments) !== null && _a !== void 0 ? _a : [];
+    }
+    getCodeFragment(name) {
+        var _a;
+        return (_a = this.fragments.find(it => it.interface === name)) === null || _a === void 0 ? void 0 : _a.methods;
+    }
+}
+
 /*
  * Copyright (c) 2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -13504,7 +13679,7 @@ function main() {
     if (options.initialize) {
         new StaticEmitter(options.outputDir, options.pandaSdkPath).emit();
     }
-    new DynamicEmitter(options.outputDir, toIDLFile(path__namespace$1.join(options.pandaSdkPath, pandaSdkIdlFilePath), { inheritanceMode: 'single' })[0], new Config(new IgnoreOptions(options.optionsFile), new NonNullableOptions(options.optionsFile), new IrHackOptions(options.optionsFile)), options.debug).emit();
+    new DynamicEmitter(options.outputDir, toIDLFile(path__namespace$1.join(options.pandaSdkPath, pandaSdkIdlFilePath), { inheritanceMode: 'single' })[0], new Config(new IgnoreOptions(options.optionsFile), new NonNullableOptions(options.optionsFile), new IrHackOptions(options.optionsFile), new CodeFragmentOptions(options.optionsFile)), options.debug).emit();
 }
 main();
 //# sourceMappingURL=index.js.map