@gtkx/ffi 0.1.5 → 0.1.7

package/dist/codegen/ffi-generator.js

@@ -48,10 +48,24 @@ const RESERVED_WORDS = new Set([
     "public",
     "await",
     "async",
+    "eval",
+    "arguments",
 ]);
 const METHOD_RENAMES = new Map([
-    ["IconView", new Map([["setCursor", "setCursorPath"]])],
-    ["TreeView", new Map([["setCursor", "setCursorPath"]])],
+    [
+        "IconView",
+        new Map([
+            ["setCursor", "setCursorPath"],
+            ["getCursor", "getCursorPath"],
+        ]),
+    ],
+    [
+        "TreeView",
+        new Map([
+            ["setCursor", "setCursorPath"],
+            ["getCursor", "getCursorPath"],
+        ]),
+    ],
     ["HSV", new Map([["getColor", "getHsvColor"]])],
     ["Layout", new Map([["getSize", "getLayoutSize"]])],
     ["Table", new Map([["getSize", "getTableSize"]])],
@@ -66,8 +80,13 @@ const METHOD_RENAMES = new Map([
             ["setDirection", "setArrowDirection"],
         ]),
     ],
+    ["PrintUnixDialog", new Map([["getSettings", "getPrintSettings"]])],
 ]);
-const toKebabCase = (str) => str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+const CLASS_RENAMES = new Map([["Error", "GError"]]);
+const toKebabCase = (str) => str
+    .replace(/([a-z])([A-Z])/g, "$1-$2")
+    .replace(/_/g, "-")
+    .toLowerCase();
 const toConstantCase = (str) => str.replace(/-/g, "_").toUpperCase();
 const sanitizeDoc = (doc) => {
     let result = doc;
@@ -126,7 +145,16 @@ const toValidIdentifier = (str) => {
         result = `_${result}`;
     return result;
 };
-const normalizeClassName = (name) => (name === "Object" ? "GObject" : toPascalCase(name));
+const normalizeClassName = (name) => {
+    const pascalName = toPascalCase(name);
+    if (CLASS_RENAMES.has(pascalName)) {
+        return CLASS_RENAMES.get(pascalName);
+    }
+    if (pascalName === "Object") {
+        return "GObject";
+    }
+    return pascalName;
+};
 const hasOutParameter = (params) => params.some((p) => p.direction === "out" || p.direction === "inout");
 const isVararg = (param) => param.name === "..." || param.name === "";
 export class CodeGenerator {
@@ -134,32 +162,58 @@ export class CodeGenerator {
     typeMapper;
     usesRef = false;
     usesCall = false;
+    addGioImport = false;
     usesType = false;
+    usesRead = false;
+    usesWrite = false;
+    usesAlloc = false;
+    usesNativeError = false;
     usedEnums = new Set();
+    usedRecords = new Set();
+    usedExternalTypes = new Map();
+    usedSameNamespaceClasses = new Map();
+    usedInterfaces = new Map();
     signalClasses = new Set();
+    recordNameToFile = new Map();
+    interfaceNameToFile = new Map();
+    currentSharedLibrary = "";
+    cyclicReturnTypes = new Set();
     constructor(options) {
         this.options = options;
         this.typeMapper = new TypeMapper();
+        if (options.typeRegistry) {
+            this.typeMapper.setTypeRegistry(options.typeRegistry, options.namespace);
+        }
     }
     async generateNamespace(namespace) {
         const files = new Map();
+        this.currentSharedLibrary = namespace.sharedLibrary;
         this.registerEnumsAndBitfields(namespace);
+        this.registerRecords(namespace);
+        this.registerInterfaces(namespace);
         const classMap = this.buildClassMap(namespace);
+        const interfaceMap = this.buildInterfaceMap(namespace);
         this.attachConstructorFunctions(namespace, classMap);
+        const allEnums = [...namespace.enumerations, ...namespace.bitfields];
+        if (allEnums.length > 0) {
+            files.set("enums.ts", await this.generateEnums(allEnums));
+        }
+        for (const record of namespace.records) {
+            if (this.shouldGenerateRecord(record)) {
+                files.set(`${toKebabCase(record.name)}.ts`, await this.generateRecord(record, namespace.sharedLibrary));
+            }
+        }
+        const sortedClasses = this.topologicalSortClasses(namespace.classes, classMap);
+        for (const cls of sortedClasses) {
+            files.set(`${toKebabCase(cls.name)}.ts`, await this.generateClass(cls, namespace.sharedLibrary, classMap, interfaceMap));
+        }
         for (const iface of namespace.interfaces) {
             files.set(`${toKebabCase(iface.name)}.ts`, await this.generateInterface(iface, namespace.sharedLibrary, classMap));
         }
-        for (const cls of namespace.classes) {
-            files.set(`${toKebabCase(cls.name)}.ts`, await this.generateClass(cls, namespace.sharedLibrary, classMap));
-        }
         const standaloneFunctions = this.getStandaloneFunctions(namespace, classMap);
         if (standaloneFunctions.length > 0) {
             files.set("functions.ts", await this.generateFunctions(standaloneFunctions, namespace.sharedLibrary));
         }
-        const allEnums = [...namespace.enumerations, ...namespace.bitfields];
-        if (allEnums.length > 0) {
-            files.set("enums.ts", await this.generateEnums(allEnums));
-        }
         files.set("index.ts", await this.generateIndex(files.keys()));
         return files;
     }
@@ -171,6 +225,28 @@ export class CodeGenerator {
             this.typeMapper.registerEnum(bitfield.name, toPascalCase(bitfield.name));
         }
     }
+    registerRecords(namespace) {
+        for (const record of namespace.records) {
+            if (this.shouldGenerateRecord(record)) {
+                const normalizedName = normalizeClassName(record.name);
+                this.typeMapper.registerRecord(record.name, normalizedName, record.glibTypeName);
+                this.recordNameToFile.set(normalizedName, record.name);
+            }
+        }
+    }
+    shouldGenerateRecord(record) {
+        if (record.disguised)
+            return false;
+        if (record.name.endsWith("Class"))
+            return false;
+        if (record.name.endsWith("Private"))
+            return false;
+        if (record.name.endsWith("Iface"))
+            return false;
+        if (!record.glibTypeName)
+            return false;
+        return true;
+    }
     buildClassMap(namespace) {
         const classMap = new Map();
         for (const cls of namespace.classes) {
@@ -178,6 +254,19 @@ export class CodeGenerator {
         }
         return classMap;
     }
+    registerInterfaces(namespace) {
+        for (const iface of namespace.interfaces) {
+            const normalizedName = toPascalCase(iface.name);
+            this.interfaceNameToFile.set(normalizedName, iface.name);
+        }
+    }
+    buildInterfaceMap(namespace) {
+        const interfaceMap = new Map();
+        for (const iface of namespace.interfaces) {
+            interfaceMap.set(iface.name, iface);
+        }
+        return interfaceMap;
+    }
     attachConstructorFunctions(namespace, classMap) {
         for (const func of namespace.functions) {
             const match = func.cIdentifier?.match(/^[a-z_]+_([a-z_]+)_new(_.*)?$/);
@@ -213,22 +302,64 @@ export class CodeGenerator {
     resetState() {
         this.usesRef = false;
         this.usesCall = false;
+        this.addGioImport = false;
         this.usesType = false;
+        this.usesRead = false;
+        this.usesWrite = false;
+        this.usesAlloc = false;
+        this.usesNativeError = false;
         this.usedEnums.clear();
+        this.usedRecords.clear();
+        this.usedExternalTypes.clear();
+        this.usedSameNamespaceClasses.clear();
+        this.usedInterfaces.clear();
         this.signalClasses.clear();
+        this.cyclicReturnTypes.clear();
         this.typeMapper.setEnumUsageCallback((enumName) => this.usedEnums.add(enumName));
+        this.typeMapper.setRecordUsageCallback((recordName) => this.usedRecords.add(recordName));
+        this.typeMapper.setExternalTypeUsageCallback((usage) => {
+            const key = `${usage.namespace}.${usage.transformedName}`;
+            this.usedExternalTypes.set(key, usage);
+        });
+        this.typeMapper.setSameNamespaceClassUsageCallback((className, originalName) => {
+            this.usedSameNamespaceClasses.set(className, originalName);
+        });
     }
-    async generateClass(cls, sharedLibrary, classMap) {
+    async generateClass(cls, sharedLibrary, classMap, interfaceMap) {
         this.resetState();
+        this.cyclicReturnTypes = this.computeCyclicReturnTypes(cls, classMap);
+        const asyncMethods = new Set();
+        const finishMethods = new Set();
+        for (const method of cls.methods) {
+            if (this.hasAsyncCallback(method)) {
+                asyncMethods.add(method.name);
+                finishMethods.add(`${method.name}_finish`);
+            }
+        }
+        const parentMethodNames = this.collectParentMethodNames(cls, classMap, interfaceMap);
+        const filteredClassMethods = cls.methods.filter((m) => !parentMethodNames.has(m.name));
+        const classMethodNames = new Set(cls.methods.map((m) => m.name));
+        const interfaceMethods = cls.implements
+            .flatMap((ifaceName) => interfaceMap.get(ifaceName)?.methods ?? [])
+            .filter((m) => !classMethodNames.has(m.name) && !parentMethodNames.has(m.name));
+        const syncMethods = filteredClassMethods.filter((m) => !asyncMethods.has(m.name) && !finishMethods.has(m.name));
+        const syncInterfaceMethods = interfaceMethods.filter((m) => !asyncMethods.has(m.name) && !finishMethods.has(m.name));
         this.usesRef =
-            cls.methods.some((m) => hasOutParameter(m.parameters)) ||
+            syncMethods.some((m) => hasOutParameter(m.parameters)) ||
                 cls.constructors.some((c) => hasOutParameter(c.parameters)) ||
-                cls.functions.some((f) => hasOutParameter(f.parameters));
-        this.usesCall = cls.methods.length > 0 || cls.constructors.length > 0 || cls.functions.length > 0 || cls.signals.length > 0;
+                cls.functions.some((f) => hasOutParameter(f.parameters)) ||
+                syncInterfaceMethods.some((m) => hasOutParameter(m.parameters));
+        this.usesCall =
+            filteredClassMethods.length > 0 ||
+                cls.constructors.length > 0 ||
+                cls.functions.length > 0 ||
+                cls.signals.length > 0 ||
+                interfaceMethods.length > 0;
         const className = normalizeClassName(cls.name);
         const hasParent = !!(cls.parent && classMap.has(cls.parent));
         const parentClassName = cls.parent ? normalizeClassName(cls.parent) : "";
         const extendsClause = hasParent ? ` extends ${parentClassName}` : "";
+        const implementsClause = "";
         const sections = [];
         if (hasParent && cls.parent) {
             sections.push(`import { ${parentClassName} } from "./${toKebabCase(cls.parent)}.js";`);
@@ -237,15 +368,18 @@ export class CodeGenerator {
         if (cls.doc) {
             sections.push(formatDoc(cls.doc));
         }
-        sections.push(`export class ${className}${extendsClause} {`);
+        sections.push(`export class ${className}${extendsClause}${implementsClause} {`);
         if (!extendsClause) {
             sections.push(`  ptr: unknown;\n`);
         }
         sections.push(this.generateConstructors(cls, sharedLibrary, hasParent));
         sections.push(this.generateCreatePtr(cls, sharedLibrary, hasParent));
         sections.push(this.generateStaticFunctions(cls.functions, sharedLibrary, className));
-        sections.push(this.generateMethods(cls.methods, sharedLibrary, cls.name));
+        sections.push(this.generateMethods(filteredClassMethods, sharedLibrary, cls.name));
         sections.push(this.generateProperties(cls.properties, cls.methods));
+        if (interfaceMethods.length > 0) {
+            sections.push(this.generateMethods(interfaceMethods, sharedLibrary, className));
+        }
         if (cls.signals.length > 0) {
             const hasConnectMethod = cls.methods.some((m) => toCamelCase(m.name) === "connect");
             sections.push(this.generateSignalConnect(sharedLibrary, cls.signals, hasConnectMethod, classMap));
@@ -254,6 +388,124 @@ export class CodeGenerator {
         const imports = this.generateImports(className, hasParent ? parentClassName : undefined);
         return this.formatCode(imports + sections.join("\n"));
     }
+    topologicalSortClasses(classes, classMap) {
+        const sorted = [];
+        const visited = new Set();
+        const visit = (cls) => {
+            if (visited.has(cls.name))
+                return;
+            visited.add(cls.name);
+            if (cls.parent && classMap.has(cls.parent)) {
+                const parent = classMap.get(cls.parent);
+                visit(parent);
+            }
+            sorted.push(cls);
+        };
+        for (const cls of classes) {
+            visit(cls);
+        }
+        return sorted;
+    }
+    isDescendantOf(className, ancestorName, classMap) {
+        const cls = classMap.get(className);
+        if (!cls)
+            return false;
+        if (cls.parent === ancestorName)
+            return true;
+        if (cls.parent && classMap.has(cls.parent)) {
+            return this.isDescendantOf(cls.parent, ancestorName, classMap);
+        }
+        return false;
+    }
+    computeCyclicReturnTypes(cls, classMap) {
+        const cyclic = new Set();
+        for (const method of cls.methods) {
+            const returnTypeName = method.returnType.name;
+            if (returnTypeName && classMap.has(returnTypeName)) {
+                if (this.wouldCreateCycle(cls.name, returnTypeName, classMap)) {
+                    cyclic.add(normalizeClassName(returnTypeName));
+                }
+            }
+        }
+        for (const func of cls.functions) {
+            const returnTypeName = func.returnType.name;
+            if (returnTypeName && classMap.has(returnTypeName)) {
+                if (this.wouldCreateCycle(cls.name, returnTypeName, classMap)) {
+                    cyclic.add(normalizeClassName(returnTypeName));
+                }
+            }
+        }
+        return cyclic;
+    }
+    wouldCreateCycle(currentClass, returnType, classMap) {
+        if (this.isDescendantOf(returnType, currentClass, classMap)) {
+            return true;
+        }
+        const returnTypeClass = classMap.get(returnType);
+        if (!returnTypeClass)
+            return false;
+        const ancestors = this.getAncestors(returnType, classMap);
+        for (const ancestor of ancestors) {
+            const ancestorClass = classMap.get(ancestor);
+            if (!ancestorClass)
+                continue;
+            if (this.classImports(ancestorClass, currentClass, classMap)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getAncestors(className, classMap) {
+        const ancestors = [];
+        let current = classMap.get(className);
+        while (current?.parent && classMap.has(current.parent)) {
+            ancestors.push(current.parent);
+            current = classMap.get(current.parent);
+        }
+        return ancestors;
+    }
+    classImports(cls, targetClass, _classMap) {
+        for (const method of cls.methods) {
+            if (method.returnType.name === targetClass)
+                return true;
+            for (const param of method.parameters) {
+                if (param.type.name === targetClass)
+                    return true;
+            }
+        }
+        for (const func of cls.functions) {
+            if (func.returnType.name === targetClass)
+                return true;
+            for (const param of func.parameters) {
+                if (param.type.name === targetClass)
+                    return true;
+            }
+        }
+        for (const prop of cls.properties) {
+            if (prop.type.name === targetClass)
+                return true;
+        }
+        return false;
+    }
+    collectParentMethodNames(cls, classMap, interfaceMap) {
+        const names = new Set();
+        let current = cls.parent ? classMap.get(cls.parent) : undefined;
+        while (current) {
+            for (const method of current.methods) {
+                names.add(method.name);
+            }
+            for (const ifaceName of current.implements) {
+                const iface = interfaceMap.get(ifaceName);
+                if (iface) {
+                    for (const method of iface.methods) {
+                        names.add(method.name);
+                    }
+                }
+            }
+            current = current.parent ? classMap.get(current.parent) : undefined;
+        }
+        return names;
+    }
     generateConstructors(cls, _sharedLibrary, hasParent) {
         const mainConstructor = cls.constructors.find((c) => !c.parameters.some(isVararg));
         const sections = [];
@@ -317,7 +569,7 @@ export class CodeGenerator {
             }
             return `  protected createPtr(_args: unknown[]): unknown {\n    return null;\n  }\n`;
         }
-        const filteredParams = mainConstructor.parameters.filter((p) => !isVararg(p));
+        const filteredParams = mainConstructor.parameters.filter((p, i) => !isVararg(p) && !this.typeMapper.isClosureTarget(i, mainConstructor.parameters));
         const paramTypes = filteredParams.map((p) => this.typeMapper.mapParameter(p).ts);
         const paramNames = filteredParams.map((p) => toValidIdentifier(toCamelCase(p.name)));
         const destructuring = paramNames.length > 0
@@ -439,15 +691,258 @@ ${allArgs ? `${allArgs},` : ""}
     generateMethods(methods, sharedLibrary, className) {
         const generatedMethods = new Set();
         const sections = [];
+        const asyncMethods = new Set();
+        const finishMethods = new Set();
+        for (const method of methods) {
+            if (this.hasAsyncCallback(method)) {
+                asyncMethods.add(method.name);
+                finishMethods.add(`${method.name}_finish`);
+            }
+        }
         for (const method of methods) {
             const methodKey = `${toCamelCase(method.name)}:${method.cIdentifier}`;
             if (generatedMethods.has(methodKey))
                 continue;
             generatedMethods.add(methodKey);
+            if (asyncMethods.has(method.name) || finishMethods.has(method.name)) {
+                const asyncWrapper = this.generateAsyncWrapper(method, methods, sharedLibrary, className);
+                if (asyncWrapper) {
+                    sections.push(asyncWrapper);
+                }
+                continue;
+            }
             sections.push(this.generateMethod(method, sharedLibrary, className));
         }
         return sections.join("\n");
     }
+    hasAsyncCallback(method) {
+        return method.parameters.some((p) => p.type.name === "Gio.AsyncReadyCallback");
+    }
+    findFinishMethod(asyncMethod, allMethods) {
+        const finishName = `${asyncMethod.name}_finish`;
+        return allMethods.find((m) => m.name === finishName);
+    }
+    generateAsyncWrapper(method, allMethods, sharedLibrary, className) {
+        if (!this.hasAsyncCallback(method))
+            return null;
+        const finishMethod = this.findFinishMethod(method, allMethods);
+        if (!finishMethod)
+            return null;
+        let methodName = toCamelCase(method.name);
+        if (className) {
+            const renames = METHOD_RENAMES.get(className);
+            const renamed = renames?.get(methodName);
+            if (renamed)
+                methodName = renamed;
+        }
+        const paramsWithoutCallback = method.parameters.filter((p, i) => !isVararg(p) &&
+            p.type.name !== "Gio.AsyncReadyCallback" &&
+            !this.typeMapper.isClosureTarget(i, method.parameters));
+        let hasRequiredAfterOptional = false;
+        let seenOptional = false;
+        for (const p of paramsWithoutCallback) {
+            const isOptional = this.typeMapper.isNullable(p);
+            if (isOptional)
+                seenOptional = true;
+            else if (seenOptional)
+                hasRequiredAfterOptional = true;
+        }
+        if (hasRequiredAfterOptional) {
+            return null;
+        }
+        const params = paramsWithoutCallback
+            .map((p) => {
+            const mapped = this.typeMapper.mapParameter(p);
+            const paramName = toValidIdentifier(toCamelCase(p.name));
+            const isOptional = this.typeMapper.isNullable(p);
+            return `${paramName}${isOptional ? "?" : ""}: ${mapped.ts}`;
+        })
+            .join(", ");
+        const finishParams = finishMethod.parameters.filter((p) => !isVararg(p));
+        const outputParams = finishParams.filter((p) => p.direction === "out" || (p.type.name !== "Gio.AsyncResult" && p.direction !== "in"));
+        const returnTypeMapping = this.typeMapper.mapType(finishMethod.returnType, true);
+        const mainReturnType = returnTypeMapping.ts;
+        const hasMainReturn = mainReturnType !== "void";
+        this.addGioImport = true;
+        const promiseType = this.buildAsyncReturnType(hasMainReturn, mainReturnType, outputParams);
+        const lines = [];
+        lines.push(`  /**`);
+        lines.push(`   * Promise-based version of ${methodName}.`);
+        if (method.doc) {
+            const docLines = sanitizeDoc(method.doc).split("\n").slice(0, 3);
+            for (const line of docLines) {
+                lines.push(`   * ${line.trim()}`);
+            }
+        }
+        lines.push(`   */`);
+        lines.push(`  ${methodName}(${params}): Promise<${promiseType}> {`);
+        lines.push(`    return new Promise((resolve, reject) => {`);
+        const callArgs = this.buildAsyncCallArgs(method, finishMethod, outputParams, sharedLibrary);
+        lines.push(callArgs);
+        lines.push(`    });`);
+        lines.push(`  }`);
+        return `${lines.join("\n")}\n`;
+    }
+    buildAsyncReturnType(hasMainReturn, mainReturnType, outputParams) {
+        if (outputParams.length === 0) {
+            return hasMainReturn ? mainReturnType : "void";
+        }
+        const outputTypes = [];
+        if (hasMainReturn) {
+            outputTypes.push(`result: ${mainReturnType}`);
+        }
+        for (const param of outputParams) {
+            const paramName = toValidIdentifier(toCamelCase(param.name));
+            const mapped = this.typeMapper.mapParameter(param);
+            let paramType = mapped.ts;
+            if (paramType.startsWith("Ref<") && paramType.endsWith(">")) {
+                paramType = paramType.slice(4, -1);
+            }
+            outputTypes.push(`${paramName}: ${paramType}`);
+        }
+        return `{ ${outputTypes.join("; ")} }`;
+    }
+    buildAsyncCallArgs(method, finishMethod, outputParams, sharedLibrary) {
+        const returnTypeMapping = this.typeMapper.mapType(finishMethod.returnType, true);
+        const hasMainReturn = returnTypeMapping.ts !== "void";
+        const needsObjectWrap = (returnTypeMapping.ffi.type === "gobject" || returnTypeMapping.ffi.type === "boxed") &&
+            returnTypeMapping.ts !== "unknown";
+        const lines = [];
+        for (const param of outputParams) {
+            const paramName = toValidIdentifier(toCamelCase(param.name));
+            lines.push(`      const ${paramName}Ref = { value: null as unknown };`);
+        }
+        const nonCallbackParams = method.parameters.filter((p, i) => !isVararg(p) &&
+            p.type.name !== "Gio.AsyncReadyCallback" &&
+            !this.typeMapper.isClosureTarget(i, method.parameters));
+        const asyncCallArgs = nonCallbackParams
+            .map((param) => {
+            const mapped = this.typeMapper.mapParameter(param);
+            const jsParamName = toValidIdentifier(toCamelCase(param.name));
+            const needsPtr = mapped.ffi.type === "gobject" || mapped.ffi.type === "boxed";
+            const valueName = needsPtr ? `(${jsParamName} as any)?.ptr ?? ${jsParamName}` : jsParamName;
+            return `          {\n            type: ${this.generateTypeDescriptor(mapped.ffi)},\n            value: ${valueName},\n          }`;
+        })
+            .join(",\n");
+        const finishCallArgs = this.generateFinishCallArguments(finishMethod.parameters, outputParams);
+        const finishReturnType = this.typeMapper.mapType(finishMethod.returnType, true);
+        lines.push(`      const callback = (_source: unknown, asyncResult: unknown) => {`);
+        lines.push(`        try {`);
+        if (finishMethod.throws) {
+            lines.push(`          const error = { value: null as unknown };`);
+        }
+        const errorArg = finishMethod.throws
+            ? `,\n            { type: { type: "ref", innerType: { type: "boxed", innerType: "GError", lib: "libglib-2.0.so.0" } }, value: error }`
+            : "";
+        if (hasMainReturn) {
+            const varName = needsObjectWrap ? "ptr" : "result";
+            const castType = needsObjectWrap ? "unknown" : finishReturnType.ts;
+            lines.push(`          const ${varName} = call(`);
+            lines.push(`            "${sharedLibrary}",`);
+            lines.push(`            "${finishMethod.cIdentifier}",`);
+            lines.push(`            [`);
+            lines.push(`              { type: { type: "gobject" }, value: this.ptr },`);
+            lines.push(`${finishCallArgs}${errorArg}`);
+            lines.push(`            ],`);
+            lines.push(`            ${this.generateTypeDescriptor(finishReturnType.ffi)}`);
+            lines.push(`          ) as ${castType};`);
+        }
+        else {
+            lines.push(`          call(`);
+            lines.push(`            "${sharedLibrary}",`);
+            lines.push(`            "${finishMethod.cIdentifier}",`);
+            lines.push(`            [`);
+            lines.push(`              { type: { type: "gobject" }, value: this.ptr },`);
+            lines.push(`${finishCallArgs}${errorArg}`);
+            lines.push(`            ],`);
+            lines.push(`            { type: "undefined" }`);
+            lines.push(`          );`);
+        }
+        if (finishMethod.throws) {
+            lines.push(`          if (error.value !== null) {`);
+            lines.push(`            throw new NativeError(error.value);`);
+            lines.push(`          }`);
+            this.usesNativeError = true;
+        }
+        if (outputParams.length === 0) {
+            if (hasMainReturn) {
+                if (needsObjectWrap) {
+                    lines.push(`          if (ptr === null) { resolve(null as unknown as ${finishReturnType.ts}); return; }`);
+                    lines.push(`          const instance = Object.create(${finishReturnType.ts}.prototype) as ${finishReturnType.ts} & { ptr: unknown };`);
+                    lines.push(`          instance.ptr = ptr;`);
+                    lines.push(`          resolve(instance);`);
+                }
+                else {
+                    lines.push(`          resolve(result);`);
+                }
+            }
+            else {
+                lines.push(`          resolve();`);
+            }
+        }
+        else {
+            const resolveFields = [];
+            if (hasMainReturn) {
+                if (needsObjectWrap) {
+                    lines.push(`          const result = (ptr === null ? null : (() => {`);
+                    lines.push(`            const instance = Object.create(${finishReturnType.ts}.prototype) as ${finishReturnType.ts} & { ptr: unknown };`);
+                    lines.push(`            instance.ptr = ptr;`);
+                    lines.push(`            return instance;`);
+                    lines.push(`          })()) as ${finishReturnType.ts};`);
+                }
+                resolveFields.push("result");
+            }
+            for (const param of outputParams) {
+                const paramName = toValidIdentifier(toCamelCase(param.name));
+                const mapped = this.typeMapper.mapParameter(param);
+                let paramType = mapped.ts;
+                if (paramType.startsWith("Ref<") && paramType.endsWith(">")) {
+                    paramType = paramType.slice(4, -1);
+                }
+                resolveFields.push(`${paramName}: ${paramName}Ref.value as ${paramType}`);
+            }
+            lines.push(`          resolve({ ${resolveFields.join(", ")} });`);
+        }
+        lines.push(`        } catch (err) {`);
+        lines.push(`          reject(err);`);
+        lines.push(`        }`);
+        lines.push(`      };`);
+        lines.push(`      call(`);
+        lines.push(`        "${sharedLibrary}",`);
+        lines.push(`        "${method.cIdentifier}",`);
+        lines.push(`        [`);
+        lines.push(`          { type: { type: "gobject" }, value: this.ptr },`);
+        if (asyncCallArgs) {
+            lines.push(`${asyncCallArgs},`);
+        }
+        lines.push(`          {`);
+        lines.push(`            type: { type: "asyncCallback", sourceType: { type: "gobject", borrowed: true }, resultType: { type: "gobject", borrowed: true } },`);
+        lines.push(`            value: callback,`);
+        lines.push(`          },`);
+        lines.push(`        ],`);
+        lines.push(`        { type: "undefined" }`);
+        lines.push(`      );`);
+        return lines.join("\n");
+    }
+    generateFinishCallArguments(parameters, outputParams) {
+        return parameters
+            .filter((p) => !isVararg(p))
+            .map((param) => {
+            const paramName = toValidIdentifier(toCamelCase(param.name));
+            if (param.type.name === "Gio.AsyncResult") {
+                return `              { type: { type: "gobject" }, value: asyncResult }`;
+            }
+            if (outputParams.some((op) => op.name === param.name)) {
+                const mapped = this.typeMapper.mapParameter(param);
+                return `              { type: ${this.generateTypeDescriptor(mapped.ffi)}, value: ${paramName}Ref }`;
+            }
+            const mapped = this.typeMapper.mapParameter(param);
+            const needsPtr = mapped.ffi.type === "gobject" || mapped.ffi.type === "boxed";
+            const valueName = needsPtr ? `(${paramName} as any)?.ptr ?? ${paramName}` : paramName;
+            return `              { type: ${this.generateTypeDescriptor(mapped.ffi)}, value: ${valueName} }`;
+        })
+            .join(",\n");
+    }
     generateMethod(method, sharedLibrary, className) {
         let methodName = toCamelCase(method.name);
         if (className) {
@@ -463,7 +958,9 @@ ${allArgs ? `${allArgs},` : ""}
         const returnTypeAnnotation = tsReturnType !== "void" ? `: ${tsReturnType}` : "";
         const hasResultParam = method.parameters.some((p) => toValidIdentifier(toCamelCase(p.name)) === "result");
         const resultVarName = hasResultParam ? "_result" : "result";
-        const needsCast = returnTypeMapping.ts !== "void" && returnTypeMapping.ts !== "unknown";
+        const needsObjectWrap = (returnTypeMapping.ffi.type === "gobject" || returnTypeMapping.ffi.type === "boxed") &&
+            tsReturnType !== "unknown" &&
+            returnTypeMapping.kind !== "interface";
         const hasReturnValue = returnTypeMapping.ts !== "void";
         const lines = [];
         const methodDoc = formatMethodDoc(method.doc, method.parameters);
@@ -474,17 +971,46 @@ ${allArgs ? `${allArgs},` : ""}
         if (method.throws) {
             lines.push(`    const error = { value: null as unknown };`);
         }
-        const callPrefix = method.throws
-            ? hasReturnValue
-                ? `const ${resultVarName} = `
-                : ""
-            : hasReturnValue
-                ? "return "
-                : "";
         const args = this.generateCallArguments(method.parameters);
         const errorArg = method.throws ? this.generateErrorArgument() : "";
         const allArgs = errorArg ? args + (args ? ",\n" : "") + errorArg : args;
-        lines.push(`    ${callPrefix}call(
+        if (needsObjectWrap && hasReturnValue) {
+            const isCyclic = this.cyclicReturnTypes.has(tsReturnType);
+            lines.push(`    const ptr = call(
+      "${sharedLibrary}",
+      "${method.cIdentifier}",
+      [
+        {
+          type: { type: "gobject" },
+          value: this.ptr,
+        },
+${allArgs ? `${allArgs},` : ""}
+      ],
+      ${this.generateTypeDescriptor(returnTypeMapping.ffi)}
+    );`);
+            if (method.throws) {
+                lines.push(this.generateErrorCheck());
+            }
+            lines.push(`    if (ptr === null) return null as unknown as ${tsReturnType};`);
+            if (isCyclic) {
+                lines.push(`    return { ptr } as unknown as ${tsReturnType};`);
+            }
+            else {
+                lines.push(`    const instance = Object.create(${tsReturnType}.prototype) as ${tsReturnType} & { ptr: unknown };`);
+                lines.push(`    instance.ptr = ptr;`);
+                lines.push(`    return instance;`);
+            }
+        }
+        else {
+            const callPrefix = method.throws
+                ? hasReturnValue
+                    ? `const ${resultVarName} = `
+                    : ""
+                : hasReturnValue
+                    ? "return "
+                    : "";
+            const needsCast = returnTypeMapping.ts !== "void" && returnTypeMapping.ts !== "unknown";
+            lines.push(`    ${callPrefix}call(
       "${sharedLibrary}",
       "${method.cIdentifier}",
       [
@@ -496,10 +1022,11 @@ ${allArgs ? `${allArgs},` : ""}
       ],
       ${this.generateTypeDescriptor(returnTypeMapping.ffi)}
     )${needsCast ? ` as ${tsReturnType}` : ""};`);
-        if (method.throws) {
-            lines.push(this.generateErrorCheck());
-            if (hasReturnValue) {
-                lines.push(`    return ${resultVarName};`);
+            if (method.throws) {
+                lines.push(this.generateErrorCheck());
+                if (hasReturnValue) {
+                    lines.push(`    return ${resultVarName};`);
+                }
             }
         }
         lines.push(`  }`);
@@ -561,8 +1088,12 @@ ${allArgs ? `${allArgs},` : ""}
     }
     generateSignalConnect(sharedLibrary, signals, hasConnectMethod, classMap) {
         const methodName = hasConnectMethod ? "on" : "connect";
-        const savedCallback = this.typeMapper.getEnumUsageCallback();
+        const savedEnumCallback = this.typeMapper.getEnumUsageCallback();
+        const savedRecordCallback = this.typeMapper.getRecordUsageCallback();
         this.typeMapper.setEnumUsageCallback(null);
+        this.typeMapper.setRecordUsageCallback(null);
+        this.typeMapper.setExternalTypeUsageCallback(null);
+        this.typeMapper.setSameNamespaceClassUsageCallback(null);
         const signalMetadata = signals.map((signal) => {
             const paramEntries = (signal.parameters ?? []).map((param) => {
                 const ffiType = JSON.stringify(this.typeMapper.mapType(param.type).ffi);
@@ -575,7 +1106,15 @@ ${allArgs ? `${allArgs},` : ""}
             });
             return `    "${signal.name}": [${paramEntries.join(", ")}]`;
         });
-        this.typeMapper.setEnumUsageCallback(savedCallback);
+        this.typeMapper.setEnumUsageCallback(savedEnumCallback);
+        this.typeMapper.setRecordUsageCallback(savedRecordCallback);
+        this.typeMapper.setExternalTypeUsageCallback((usage) => {
+            const key = `${usage.namespace}.${usage.transformedName}`;
+            this.usedExternalTypes.set(key, usage);
+        });
+        this.typeMapper.setSameNamespaceClassUsageCallback((className, originalName) => {
+            this.usedSameNamespaceClasses.set(className, originalName);
+        });
         this.usesType = true;
         const signalMapCode = signalMetadata.length > 0
             ? `const signalMeta: Record<string, { type: Type; cls?: { prototype: object } }[]> = {\n${signalMetadata.join(",\n")}\n  };
@@ -617,27 +1156,350 @@ ${allArgs ? `${allArgs},` : ""}
   }
 `;
     }
-    async generateInterface(iface, sharedLibrary, classMap) {
+    async generateInterface(iface, sharedLibrary, _classMap) {
         this.resetState();
-        this.usesRef = iface.methods.some((m) => hasOutParameter(m.parameters));
-        this.usesCall = iface.methods.length > 0 || iface.signals.length > 0;
         const interfaceName = toPascalCase(iface.name);
         const sections = [];
+        this.usesCall = iface.methods.length > 0;
+        this.usesRef = iface.methods.some((m) => hasOutParameter(m.parameters));
         if (iface.doc) {
             sections.push(formatDoc(iface.doc));
         }
-        sections.push(`export abstract class ${interfaceName} {`);
-        sections.push(`  protected abstract ptr: unknown;\n`);
-        sections.push(this.generateMethods(iface.methods, sharedLibrary, iface.name));
-        sections.push(this.generateProperties(iface.properties, iface.methods));
-        if (iface.signals.length > 0) {
-            const hasConnectMethod = iface.methods.some((m) => toCamelCase(m.name) === "connect");
-            sections.push(this.generateSignalConnect(sharedLibrary, iface.signals, hasConnectMethod, classMap));
+        sections.push(`export class ${interfaceName} {`);
+        sections.push(`  ptr: unknown;`);
+        sections.push(``);
+        sections.push(`  protected constructor(ptr: unknown) {`);
+        sections.push(`    this.ptr = ptr;`);
+        sections.push(`  }`);
+        sections.push(``);
+        sections.push(`  static fromPtr(ptr: unknown): ${interfaceName} {`);
+        sections.push(`    return new ${interfaceName}(ptr);`);
+        sections.push(`  }`);
+        if (iface.methods.length > 0) {
+            sections.push(this.generateMethods(iface.methods, sharedLibrary, interfaceName));
         }
         sections.push("}");
         const imports = this.generateImports(interfaceName);
         return this.formatCode(imports + sections.join("\n"));
     }
+    async generateRecord(record, sharedLibrary) {
+        this.resetState();
+        this.usesRef =
+            record.methods.some((m) => hasOutParameter(m.parameters)) ||
+                record.constructors.some((c) => hasOutParameter(c.parameters)) ||
+                record.functions.some((f) => hasOutParameter(f.parameters));
+        this.usesCall = record.methods.length > 0 || record.constructors.length > 0 || record.functions.length > 0;
+        const hasReadableFields = record.fields.some((f) => f.readable !== false && !f.private);
+        if (hasReadableFields) {
+            this.usesRead = true;
+        }
+        const recordName = normalizeClassName(record.name);
+        const sections = [];
+        const initInterface = this.generateRecordInitInterface(record);
+        if (initInterface) {
+            sections.push(initInterface);
+        }
+        if (record.doc) {
+            sections.push(formatDoc(record.doc));
+        }
+        sections.push(`export class ${recordName} {`);
+        sections.push(`  ptr: unknown;\n`);
+        sections.push(this.generateRecordConstructors(record, sharedLibrary));
+        sections.push(this.generateRecordStaticFunctions(record.functions, sharedLibrary, recordName));
+        sections.push(this.generateRecordMethods(record.methods, sharedLibrary, record.name));
+        sections.push(this.generateRecordFields(record.fields, record.methods));
+        sections.push("}");
+        const imports = this.generateImports(recordName);
+        return this.formatCode(imports + sections.join("\n"));
+    }
+    generateRecordInitInterface(record) {
+        const mainConstructor = record.constructors.find((c) => !c.parameters.some(isVararg));
+        if (mainConstructor)
+            return null;
+        const initFields = this.getWritableFields(record.fields);
+        if (initFields.length === 0)
+            return null;
+        const recordName = normalizeClassName(record.name);
+        return this.generateFieldInitInterface(recordName, initFields);
+    }
+    generateRecordConstructors(record, sharedLibrary) {
+        const recordName = normalizeClassName(record.name);
+        const sections = [];
+        const mainConstructor = record.constructors.find((c) => !c.parameters.some(isVararg));
+        if (mainConstructor) {
+            const ctorDoc = formatMethodDoc(mainConstructor.doc, mainConstructor.parameters);
+            const filteredParams = mainConstructor.parameters.filter((p) => !isVararg(p));
+            if (filteredParams.length === 0) {
+                sections.push(`${ctorDoc}  constructor() {\n    this.ptr = this.createPtr([]);\n  }\n`);
+            }
+            else {
+                const typedParams = this.generateParameterList(mainConstructor.parameters, false);
+                const paramNames = filteredParams.map((p) => toValidIdentifier(toCamelCase(p.name)));
+                const firstParamType = this.typeMapper.mapParameter(filteredParams[0]).ts;
+                const isFirstParamArray = firstParamType.endsWith("[]") || firstParamType.startsWith("Array<");
+                if (isFirstParamArray) {
+                    sections.push(`${ctorDoc}  constructor(${typedParams}) {
+    const _args = [${paramNames.join(", ")}];
+    this.ptr = this.createPtr(_args);
+  }
+`);
+                }
+                else {
+                    sections.push(`${ctorDoc}  constructor(${typedParams});
+  constructor(_args: unknown[]);
+  constructor(...args: unknown[]) {
+    const _args = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+    this.ptr = this.createPtr(_args);
+  }
+`);
+                }
+            }
+            for (const ctor of record.constructors) {
+                if (ctor !== mainConstructor) {
+                    sections.push(this.generateRecordStaticFactoryMethod(ctor, recordName, sharedLibrary));
+                }
+            }
+        }
+        else {
+            const initFields = this.getWritableFields(record.fields);
+            if (initFields.length > 0) {
+                sections.push(`  constructor(init: ${recordName}Init = {}) {\n    this.ptr = this.createPtr(init);\n  }\n`);
+            }
+            else {
+                sections.push(`  constructor() {\n    this.ptr = this.createPtr({});\n  }\n`);
+            }
+        }
+        sections.push(this.generateRecordCreatePtr(record, sharedLibrary));
+        return sections.join("\n");
+    }
+    getWritableFields(fields) {
+        return fields.filter((f) => !f.private && f.writable !== false && this.isWritableType(f.type));
+    }
+    generateFieldInitInterface(recordName, fields) {
+        const properties = fields.map((field) => {
+            const fieldName = toValidIdentifier(toCamelCase(field.name));
+            const typeMapping = this.typeMapper.mapType(field.type);
+            return `  ${fieldName}?: ${typeMapping.ts};`;
+        });
+        return `export interface ${recordName}Init {\n${properties.join("\n")}\n}\n\n`;
+    }
+    generateRecordCreatePtr(record, sharedLibrary) {
+        const recordName = normalizeClassName(record.name);
+        const mainConstructor = record.constructors.find((c) => !c.parameters.some(isVararg));
+        if (!mainConstructor) {
+            if (record.glibTypeName && record.fields.length > 0) {
+                const structSize = this.calculateStructSize(record.fields);
+                const initFields = this.getWritableFields(record.fields);
+                this.usesAlloc = true;
+                if (initFields.length > 0) {
+                    const fieldWrites = this.generateFieldWrites(record.fields);
+                    this.usesWrite = true;
+                    return `  protected createPtr(init: ${recordName}Init): unknown {
+    const ptr = alloc(${structSize}, "${record.glibTypeName}", "${sharedLibrary}");
+${fieldWrites}
+    return ptr;
+  }
+`;
+                }
+                return `  protected createPtr(_init: Record<string, unknown>): unknown {
+    return alloc(${structSize}, "${record.glibTypeName}", "${sharedLibrary}");
+  }
+`;
+            }
+            return `  protected createPtr(_init: Record<string, unknown>): unknown {\n    return null;\n  }\n`;
+        }
+        const filteredParams = mainConstructor.parameters.filter((p) => !isVararg(p));
+        const paramTypes = filteredParams.map((p) => this.typeMapper.mapParameter(p).ts);
+        const paramNames = filteredParams.map((p) => toValidIdentifier(toCamelCase(p.name)));
+        const destructuring = paramNames.length > 0
+            ? `    const [${paramNames.join(", ")}] = _args as [${paramTypes.join(", ")}];\n`
+            : "";
+        const args = this.generateCallArguments(mainConstructor.parameters);
+        const glibTypeName = record.glibTypeName ?? record.cType;
+        return `  protected createPtr(_args: unknown[]): unknown {
+${destructuring}    return call(
+      "${sharedLibrary}",
+      "${mainConstructor.cIdentifier}",
+      [
+${args}
+      ],
+      { type: "boxed", borrowed: true, innerType: "${glibTypeName}" }
+    );
+  }
+`;
+    }
+    generateFieldWrites(fields) {
+        const writes = [];
+        let currentOffset = 0;
+        for (const field of fields) {
+            if (field.private)
+                continue;
+            const fieldSize = this.getFieldSize(field.type);
+            const alignment = this.getFieldAlignment(field.type);
+            currentOffset = Math.ceil(currentOffset / alignment) * alignment;
+            if (field.writable !== false && this.isWritableType(field.type)) {
+                const fieldName = toValidIdentifier(toCamelCase(field.name));
+                const typeMapping = this.typeMapper.mapType(field.type);
+                writes.push(`    if (init.${fieldName} !== undefined) write(ptr, ${this.generateTypeDescriptor(typeMapping.ffi)}, ${currentOffset}, init.${fieldName});`);
+            }
+            currentOffset += fieldSize;
+        }
+        return writes.join("\n");
+    }
+    calculateStructSize(fields) {
+        let currentOffset = 0;
+        for (const field of fields) {
+            if (field.private)
+                continue;
+            const fieldSize = this.getFieldSize(field.type);
+            const alignment = this.getFieldAlignment(field.type);
+            currentOffset = Math.ceil(currentOffset / alignment) * alignment;
+            currentOffset += fieldSize;
+        }
+        const maxAlignment = Math.max(...fields.map((f) => this.getFieldAlignment(f.type)), 1);
+        return Math.ceil(currentOffset / maxAlignment) * maxAlignment;
+    }
+    generateRecordStaticFactoryMethod(ctor, recordName, sharedLibrary) {
+        let methodName = "new";
+        if (ctor.cIdentifier) {
+            const parts = ctor.cIdentifier.split("_");
+            const nameParts = parts.slice(2).join("_");
+            if (nameParts && nameParts !== "new") {
+                methodName = toCamelCase(nameParts);
+            }
+        }
+        const params = this.generateParameterList(ctor.parameters);
+        const args = this.generateCallArguments(ctor.parameters);
+        const ctorDoc = formatMethodDoc(ctor.doc, ctor.parameters);
+        return `${ctorDoc}  static ${methodName}(${params}): ${recordName} {
+    const ptr = call(
+      "${sharedLibrary}",
+      "${ctor.cIdentifier}",
+      [
+${args}
+      ],
+      { type: "boxed", borrowed: true, innerType: "${recordName}" }
+    );
+    const instance = Object.create(${recordName}.prototype) as ${recordName} & { ptr: unknown };
+    instance.ptr = ptr;
+    return instance;
+  }
+`;
+    }
+    generateRecordStaticFunctions(functions, sharedLibrary, recordName) {
+        return this.generateStaticFunctions(functions, sharedLibrary, recordName);
+    }
+    generateRecordMethods(methods, sharedLibrary, recordName) {
+        return this.generateMethods(methods, sharedLibrary, recordName);
+    }
+    generateRecordFields(fields, methods) {
+        const sections = [];
+        const fieldOffsets = [];
+        const methodNames = new Set(methods.map((m) => toCamelCase(m.name)));
+        let currentOffset = 0;
+        for (const field of fields) {
+            if (field.private)
+                continue;
+            const fieldSize = this.getFieldSize(field.type);
+            const alignment = this.getFieldAlignment(field.type);
+            currentOffset = Math.ceil(currentOffset / alignment) * alignment;
+            fieldOffsets.push({ field, offset: currentOffset });
+            currentOffset += fieldSize;
+        }
+        for (const { field, offset } of fieldOffsets) {
+            const isReadable = field.readable !== false;
+            const isWritable = field.writable !== false;
+            if (!isReadable && !isWritable)
+                continue;
+            const fieldName = toValidIdentifier(toCamelCase(field.name));
+            if (methodNames.has(fieldName))
+                continue;
+            const typeMapping = this.typeMapper.mapType(field.type);
+            if (field.doc) {
+                sections.push(formatDoc(field.doc, "  ").trimEnd());
+            }
+            if (isReadable) {
+                sections.push(`  get ${fieldName}(): ${typeMapping.ts} {
+    return read(this.ptr, ${this.generateTypeDescriptor(typeMapping.ffi)}, ${offset}) as ${typeMapping.ts};
+  }
+`);
+            }
+            if (isWritable && this.isWritableType(field.type)) {
+                this.usesWrite = true;
+                sections.push(`  set ${fieldName}(value: ${typeMapping.ts}) {
+    write(this.ptr, ${this.generateTypeDescriptor(typeMapping.ffi)}, ${offset}, value);
+  }
+`);
+            }
+        }
+        return sections.join("\n");
+    }
+    isWritableType(type) {
+        const typeName = type.name;
+        if (typeName === "gboolean" ||
+            typeName === "guint8" ||
+            typeName === "gint8" ||
+            typeName === "guchar" ||
+            typeName === "gchar") {
+            return true;
+        }
+        if (typeName === "gint16" || typeName === "guint16" || typeName === "gshort" || typeName === "gushort") {
+            return true;
+        }
+        if (typeName === "gint" || typeName === "guint" || typeName === "gint32" || typeName === "guint32") {
+            return true;
+        }
+        if (typeName === "gint64" ||
+            typeName === "guint64" ||
+            typeName === "glong" ||
+            typeName === "gulong" ||
+            typeName === "gsize" ||
+            typeName === "gssize") {
+            return true;
+        }
+        if (typeName === "gfloat" || typeName === "float" || typeName === "gdouble" || typeName === "double") {
+            return true;
+        }
+        return false;
+    }
+    getFieldSize(type) {
+        const typeName = type.name;
+        if (typeName === "gboolean" ||
+            typeName === "guint8" ||
+            typeName === "gint8" ||
+            typeName === "guchar" ||
+            typeName === "gchar") {
+            return 1;
+        }
+        if (typeName === "gint16" || typeName === "guint16" || typeName === "gshort" || typeName === "gushort") {
+            return 2;
+        }
+        if (typeName === "gint" ||
+            typeName === "guint" ||
+            typeName === "gint32" ||
+            typeName === "guint32" ||
+            typeName === "gfloat" ||
+            typeName === "float" ||
+            typeName === "Quark" ||
+            typeName === "GQuark") {
+            return 4;
+        }
+        if (typeName === "gint64" ||
+            typeName === "guint64" ||
+            typeName === "gdouble" ||
+            typeName === "double" ||
+            typeName === "glong" ||
+            typeName === "gulong" ||
+            typeName === "gsize" ||
+            typeName === "gssize" ||
+            typeName === "GType") {
+            return 8;
+        }
+        return 8;
+    }
+    getFieldAlignment(type) {
+        return this.getFieldSize(type);
+    }
     async generateFunctions(functions, sharedLibrary) {
         this.resetState();
         this.usesRef = functions.some((f) => hasOutParameter(f.parameters));
@@ -656,7 +1518,9 @@ ${allArgs ? `${allArgs},` : ""}
         const tsReturnType = returnTypeMapping.ts === "void" ? "" : `: ${returnTypeMapping.ts}`;
         const hasResultParam = func.parameters.some((p) => toValidIdentifier(toCamelCase(p.name)) === "result");
         const resultVarName = hasResultParam ? "_result" : "result";
-        const needsCast = returnTypeMapping.ts !== "void" && returnTypeMapping.ts !== "unknown";
+        const needsObjectWrap = (returnTypeMapping.ffi.type === "gobject" || returnTypeMapping.ffi.type === "boxed") &&
+            returnTypeMapping.ts !== "unknown" &&
+            returnTypeMapping.kind !== "interface";
         const hasReturnValue = returnTypeMapping.ts !== "void";
         const lines = [];
         const funcDoc = formatMethodDoc(func.doc, func.parameters, "");
@@ -667,23 +1531,38 @@ ${allArgs ? `${allArgs},` : ""}
         if (func.throws) {
             lines.push(`  const error = { value: null as unknown };`);
         }
-        const callPrefix = func.throws
-            ? hasReturnValue
-                ? `const ${resultVarName} = `
-                : ""
-            : hasReturnValue
-                ? "return "
-                : "";
         const args = this.generateCallArguments(func.parameters, "  ");
         const errorArg = func.throws ? this.generateErrorArgument("  ") : "";
         const allArgs = errorArg ? args + (args ? ",\n" : "") + errorArg : args;
-        lines.push(`  ${callPrefix}call("${sharedLibrary}", "${func.cIdentifier}", [
+        if (needsObjectWrap && hasReturnValue) {
+            lines.push(`  const ptr = call("${sharedLibrary}", "${func.cIdentifier}", [
+${allArgs ? `${allArgs},` : ""}
+  ], ${this.generateTypeDescriptor(returnTypeMapping.ffi)});`);
+            if (func.throws) {
+                lines.push(this.generateErrorCheck(""));
+            }
+            lines.push(`  if (ptr === null) return null as unknown as ${returnTypeMapping.ts};`);
+            lines.push(`  const instance = Object.create(${returnTypeMapping.ts}.prototype) as ${returnTypeMapping.ts} & { ptr: unknown };`);
+            lines.push(`  instance.ptr = ptr;`);
+            lines.push(`  return instance;`);
+        }
+        else {
+            const callPrefix = func.throws
+                ? hasReturnValue
+                    ? `const ${resultVarName} = `
+                    : ""
+                : hasReturnValue
+                    ? "return "
+                    : "";
+            const needsCast = returnTypeMapping.ts !== "void" && returnTypeMapping.ts !== "unknown";
+            lines.push(`  ${callPrefix}call("${sharedLibrary}", "${func.cIdentifier}", [
 ${allArgs ? `${allArgs},` : ""}
   ], ${this.generateTypeDescriptor(returnTypeMapping.ffi)})${needsCast ? ` as ${returnTypeMapping.ts}` : ""};`);
-        if (func.throws) {
-            lines.push(this.generateErrorCheck(""));
-            if (hasReturnValue) {
-                lines.push(`  return ${resultVarName};`);
+            if (func.throws) {
+                lines.push(this.generateErrorCheck(""));
+                if (hasReturnValue) {
+                    lines.push(`  return ${resultVarName};`);
+                }
             }
         }
         lines.push(`};`);
@@ -711,7 +1590,7 @@ ${allArgs ? `${allArgs},` : ""}
         return this.formatCode(`${exports.join("\n")}\n`);
     }
     generateParameterList(parameters, makeAllOptional = false) {
-        const filteredParams = parameters.filter((p) => !isVararg(p));
+        const filteredParams = parameters.filter((p, i) => !isVararg(p) && !this.typeMapper.isClosureTarget(i, parameters));
         const required = [];
         const optional = [];
         for (const param of filteredParams) {
@@ -725,22 +1604,23 @@ ${allArgs ? `${allArgs},` : ""}
     }
     generateCallArguments(parameters, indent = "      ") {
         return parameters
-            .filter((p) => !isVararg(p))
+            .filter((p, i) => !isVararg(p) && !this.typeMapper.isClosureTarget(i, parameters))
             .map((param) => {
             const mapped = this.typeMapper.mapParameter(param);
             const jsParamName = toValidIdentifier(toCamelCase(param.name));
-            return `${indent}  {\n${indent}    type: ${this.generateTypeDescriptor(mapped.ffi)},\n${indent}    value: ${jsParamName},\n${indent}  }`;
+            const needsPtr = mapped.ffi.type === "gobject" || mapped.ffi.type === "boxed";
+            const valueName = needsPtr ? `(${jsParamName} as any)?.ptr ?? ${jsParamName}` : jsParamName;
+            return `${indent}  {\n${indent}    type: ${this.generateTypeDescriptor(mapped.ffi)},\n${indent}    value: ${valueName},\n${indent}  }`;
         })
             .join(",\n");
     }
     generateErrorArgument(indent = "      ") {
-        return `${indent}  {\n${indent}    type: { type: "ref", innerType: { type: "gobject" } },\n${indent}    value: error,\n${indent}  }`;
+        return `${indent}  {\n${indent}    type: { type: "ref", innerType: { type: "boxed", innerType: "GError", lib: "libglib-2.0.so.0" } },\n${indent}    value: error,\n${indent}  }`;
     }
     generateErrorCheck(indent = "  ") {
+        this.usesNativeError = true;
         return `${indent}  if (error.value !== null) {
-${indent}    const jsError = new Error("GLib Error occurred");
-${indent}    (jsError as any).gError = error.value;
-${indent}    throw jsError;
+${indent}    throw new NativeError(error.value);
 ${indent}  }`;
     }
     generateTypeDescriptor(type) {
@@ -753,18 +1633,34 @@ ${indent}  }`;
         if (type.type === "gobject") {
             return type.borrowed ? `{ type: "gobject", borrowed: true }` : `{ type: "gobject" }`;
         }
-        if (type.type === "ref" && type.innerType) {
+        if (type.type === "boxed") {
+            const innerType = typeof type.innerType === "string" ? type.innerType : "";
+            const lib = this.currentSharedLibrary;
+            return type.borrowed
+                ? `{ type: "boxed", borrowed: true, innerType: "${innerType}", lib: "${lib}" }`
+                : `{ type: "boxed", innerType: "${innerType}", lib: "${lib}" }`;
+        }
+        if (type.type === "ref" && type.innerType && typeof type.innerType !== "string") {
             return `{ type: "ref", innerType: ${this.generateTypeDescriptor(type.innerType)} }`;
         }
         if (type.type === "array" && type.itemType) {
             return `{ type: "array", itemType: ${this.generateTypeDescriptor(type.itemType)} }`;
         }
+        if (type.type === "asyncCallback" && type.sourceType && type.resultType) {
+            return `{ type: "asyncCallback", sourceType: ${this.generateTypeDescriptor(type.sourceType)}, resultType: ${this.generateTypeDescriptor(type.resultType)} }`;
+        }
         return `{ type: "${type.type}" }`;
     }
     generateImports(currentClassName, parentClassName) {
         const nativeImports = [];
+        if (this.usesAlloc)
+            nativeImports.push("alloc");
         if (this.usesCall)
             nativeImports.push("call");
+        if (this.usesRead)
+            nativeImports.push("read");
+        if (this.usesWrite)
+            nativeImports.push("write");
         if (this.usesRef)
             nativeImports.push("Ref");
         if (this.usesType)
@@ -773,15 +1669,58 @@ ${indent}  }`;
         if (nativeImports.length > 0) {
             lines.push(`import { ${nativeImports.join(", ")} } from "@gtkx/native";`);
         }
+        if (this.usesNativeError) {
+            lines.push(`import { NativeError } from "@gtkx/ffi";`);
+        }
         if (this.usedEnums.size > 0) {
             const enumList = Array.from(this.usedEnums).sort().join(", ");
             lines.push(`import { ${enumList} } from "./enums.js";`);
         }
+        for (const normalizedRecordName of Array.from(this.usedRecords).sort()) {
+            const normalizedCurrentClass = currentClassName ? normalizeClassName(currentClassName) : "";
+            const normalizedParentClass = parentClassName ? normalizeClassName(parentClassName) : "";
+            if (normalizedRecordName !== normalizedCurrentClass && normalizedRecordName !== normalizedParentClass) {
+                const originalName = this.recordNameToFile.get(normalizedRecordName) ?? normalizedRecordName;
+                lines.push(`import { ${normalizedRecordName} } from "./${toKebabCase(originalName)}.js";`);
+            }
+        }
+        for (const [interfaceName, originalName] of Array.from(this.usedInterfaces.entries()).sort((a, b) => a[0].localeCompare(b[0]))) {
+            const originalFileName = this.interfaceNameToFile.get(interfaceName) ?? originalName;
+            lines.push(`import { ${interfaceName} } from "./${toKebabCase(originalFileName)}.js";`);
+        }
+        for (const [className, originalName] of Array.from(this.usedSameNamespaceClasses.entries()).sort((a, b) => a[0].localeCompare(b[0]))) {
+            const normalizedCurrentClass = currentClassName ? normalizeClassName(currentClassName) : "";
+            const normalizedParentClass = parentClassName ? normalizeClassName(parentClassName) : "";
+            if (className !== normalizedCurrentClass &&
+                className !== normalizedParentClass &&
+                !this.signalClasses.has(className) &&
+                !this.usedInterfaces.has(className)) {
+                if (this.cyclicReturnTypes.has(className)) {
+                    lines.push(`import type { ${className} } from "./${toKebabCase(originalName)}.js";`);
+                }
+                else {
+                    lines.push(`import { ${className} } from "./${toKebabCase(originalName)}.js";`);
+                }
+            }
+        }
         for (const className of Array.from(this.signalClasses).sort()) {
             if (className !== currentClassName && className !== parentClassName) {
                 lines.push(`import { ${className} } from "./${toKebabCase(className)}.js";`);
             }
         }
+        const externalNamespaces = new Set();
+        for (const usage of this.usedExternalTypes.values()) {
+            if (usage.namespace === this.options.namespace)
+                continue;
+            externalNamespaces.add(usage.namespace);
+        }
+        if (this.addGioImport && this.options.namespace !== "Gio") {
+            externalNamespaces.add("Gio");
+        }
+        for (const namespace of Array.from(externalNamespaces).sort()) {
+            const nsLower = namespace.toLowerCase();
+            lines.push(`import * as ${namespace} from "../${nsLower}/index.js";`);
+        }
         return lines.length > 0 ? `${lines.join("\n")}\n` : "";
     }
     async formatCode(code) {