@ts-for-gir/lib 3.3.0 → 4.0.0-beta.2

package/lib/gir-module.js

@@ -1,22 +1,20 @@
 // TODO move this class into a web-worker? https://www.npmjs.com/package/web-worker
-import { Transformation, FULL_TYPE_MAP, PRIMITIVE_TYPE_MAP, ARRAY_TYPE_MAP, IGNORE_GIR_TYPE_TS_DOC_TYPES, } from './transformation.js';
-import { STATIC_NAME_ALREADY_EXISTS, MAX_CLASS_PARENT_DEPTH } from './constants.js';
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { IGNORE_GIR_TYPE_TS_DOC_TYPES, Transformation } from './transformation.js';
 import { Logger } from './logger.js';
-import { Injector } from './injection/injector.js';
-import { GirFactory } from './gir-factory.js';
-import { ConflictResolver } from './conflict-resolver.js';
 import { DependencyManager } from './dependency-manager.js';
-import { NO_TSDATA, WARN_NOT_FOUND_TYPE, WARN_CONSTANT_ALREADY_EXPORTED, WARN_DUPLICATE_SYMBOL, WARN_DUPLICATE_PARAMETER, WARN_DUPLICATE_ENUM_IDENTIFIER, } from './messages.js';
-import { isEqual, find, clone, girBool, removeNamespace, addNamespace, girElementIsIntrospectable, underscores, } from './utils.js';
+import { find } from './utils.js';
 import { SymTable } from './symtable.js';
 import { LibraryVersion } from './library-version.js';
-import { GirDirection } from './types/index.js';
+import { ClosureType, TypeIdentifier, PromiseType, VoidType, BooleanType, TupleType, BinaryType, NullableType, ObjectType, } from './gir.js';
+import { IntrospectedAlias } from './gir/alias.js';
+import { IntrospectedBase } from './gir/base.js';
+import { IntrospectedBaseClass, IntrospectedClass, IntrospectedRecord, IntrospectedInterface } from './gir/class.js';
+import { IntrospectedConstant } from './gir/const.js';
+import { IntrospectedEnum, IntrospectedError } from './gir/enum.js';
+import { IntrospectedFunction, IntrospectedCallback, } from './gir/function.js';
+import { isPrimitiveType } from './gir/util.js';
 export class GirModule {
-    config;
-    /**
-     * Array of all gir modules
-     */
-    static allGirModules = [];
     /**
      * E.g. 'Gtk'
      */
@@ -24,7 +22,7 @@ export class GirModule {
     /**
      * E.g. '4.0'
      */
-    version = '0.0';
+    version;
     /**
      * E.g. 'Gtk-4.0'
      */
@@ -35,6 +33,7 @@ export class GirModule {
      */
     importNamespace;
     importName;
+    prefixes = [];
     /**
      * The version of the library as an object.
      * E.g. `{ major: 4, minor: 0, patch: 0 }` or as string `4.0.0`'
@@ -51,44 +50,39 @@ export class GirModule {
     get allDependencies() {
         return [...new Set([...this.dependencies, ...this.transitiveDependencies])];
     }
-    repo;
-    ns = { $: { name: '', version: '0.0' } };
     /**
      * Used to find namespaces that are used in other modules
      */
     symTable;
     transformation;
-    girFactory = new GirFactory();
     dependencyManager;
-    conflictResolver;
     log;
-    inject;
     extends;
     /**
      * To prevent constants from being exported twice, the names already exported are saved here for comparison.
      * Please note: Such a case is only known for Zeitgeist-2.0 with the constant "ATTACHMENT"
      */
     constNames = {};
-    constructor(xml, config) {
+    name;
+    c_prefixes;
+    _members;
+    _enum_constants;
+    _resolve_names = new Map();
+    __dts__references;
+    package_version;
+    parent;
+    config;
+    constructor(repo, name, version, prefixes, config) {
+        this.name = name;
+        this.version = version;
+        this.c_prefixes = [...prefixes];
+        this.package_version = ['0', '0'];
         this.config = config;
-        this.repo = xml.repository;
-        if (!this.repo.namespace || !this.repo.namespace.length) {
-            throw new Error(`Namespace not found!`);
-        }
         this.dependencyManager = DependencyManager.getInstance(this.config);
-        this.dependencies = this.dependencyManager.fromGirIncludes(this.repo.include || []);
-        this.ns = this.repo.namespace[0];
-        this.namespace = this.ns.$.name;
-        this.version = this.ns.$.version;
-        this.packageName = `${this.namespace}-${this.version}`;
-        this.libraryVersion = new LibraryVersion(this.ns.constant, this.version);
-        this.transformation = new Transformation(config);
-        this.log = new Logger(config.environment, config.verbose, this.packageName || 'GirModule');
-        this.conflictResolver = new ConflictResolver(config.environment, config.verbose);
-        this.inject = new Injector(this.config.environment);
-        this.importNamespace = this.transformation.transformModuleNamespaceName(this.packageName);
-        this.importName = this.transformation.transformImportName(this.packageName);
-        this.symTable = new SymTable(this.config, this.packageName, this.namespace);
+        this.dependencies = this.dependencyManager.fromGirIncludes(repo.include || []);
+    }
+    get ns() {
+        return this;
     }
     checkTransitiveDependencies(transitiveDependencies) {
         // Always pull in GObject-2.0, as we may need it for e.g. GObject-2.0.type
@@ -121,7 +115,8 @@ export class GirModule {
             tags: [],
         };
         if (girDoc.doc?.[0]?._) {
-            let text = String(girDoc.doc?.[0]?._ || '');
+            // TODO: Somehow _ is not a string
+            let text = `${girDoc.doc?.[0]?._ || ''}`;
             text = this.transformation.transformGirDocText(text);
             tsDoc.text = text;
         }
@@ -140,22 +135,16 @@ export class GirModule {
         return tags;
     }
     getTsDocReturnTags(girElement) {
-        const girReturnValue = girElement?.['return-value']?.[0];
-        if (!girReturnValue || !girReturnValue.doc?.[0]?._) {
+        const girReturnValue = girElement?.returnTypeDoc;
+        if (!girReturnValue) {
             return [];
         }
-        try {
-            const returnTag = {
-                tagName: 'returns',
-                paramName: '',
-                text: this.transformation.transformGirDocTagText(String(girReturnValue.doc[0]._)),
-            };
-            return [returnTag];
-        }
-        catch (error) {
-            console.debug('Error: on getTsDocReturnTags, girReturnValue.doc: ', girReturnValue.doc);
-            throw error;
-        }
+        const returnTag = {
+            tagName: 'returns',
+            paramName: '',
+            text: this.transformation.transformGirDocTagText(girReturnValue),
+        };
+        return [returnTag];
     }
     getTsDocInParamTags(inParams) {
         const tags = [];
@@ -163,2118 +152,358 @@ export class GirModule {
             return tags;
         }
         for (const inParam of inParams) {
-            if (!inParam._tsData) {
-                throw new Error(NO_TSDATA('getTsDocInParamTags'));
-            }
-            if (!inParam._tsData?.doc) {
-                inParam._tsData.doc = this.getTsDoc(inParam);
-            }
-            if (inParam._tsData?.name) {
+            if (inParam.name) {
                 tags.push({
-                    paramName: inParam._tsData.name,
+                    paramName: inParam.name,
                     tagName: 'param',
-                    text: inParam._tsData.doc.text
-                        ? this.transformation.transformGirDocTagText(inParam._tsData.doc.text)
-                        : '',
+                    text: typeof inParam.doc === 'string' ? this.transformation.transformGirDocTagText(inParam.doc) : '',
                 });
             }
         }
         return tags;
     }
-    annotateFunctionArguments(girFunc) {
-        const funcName = girFunc._fullSymName;
-        if (funcName && girFunc.parameters) {
-            for (const girParams of girFunc.parameters) {
-                if (girParams.parameter) {
-                    for (const girParam of girParams.parameter) {
-                        girParam._module = this;
-                        if (girParam.$ && girParam.$.name) {
-                            girParam._fullSymName = `${funcName}.${girParam.$.name}`;
-                        }
-                    }
-                }
-            }
-        }
+    registerResolveName(resolveName, namespace, name) {
+        this._resolve_names.set(resolveName, new TypeIdentifier(name, namespace));
     }
-    annotateFunctionReturn(girFunc) {
-        const retVals = girFunc['return-value'];
-        if (retVals && girFunc._fullSymName)
-            for (const retVal of retVals) {
-                retVal._module = this;
-                retVal.girTypeName = 'callable-return';
-                if (retVal.$ && retVal.$.name) {
-                    retVal._fullSymName = `${girFunc._fullSymName}.${retVal.$.name}`;
-                }
-            }
-    }
-    /**
-     * Functions which are not part of a class
-     * @param girFuncs
-     */
-    annotateFunctions(girFuncs) {
-        if (Array.isArray(girFuncs))
-            for (const girFunc of girFuncs) {
-                if (girFunc?.$?.name) {
-                    // girFunc._girType = girType
-                    girFunc._fullSymName = `${this.namespace}.${girFunc.$.name}`;
-                    this.annotateFunctionArguments(girFunc);
-                    this.annotateFunctionReturn(girFunc);
-                }
-            }
-    }
-    /**
-     * Functions and methods of a class
-     */
-    annotateMethods(girClass, girFuncs) {
-        if (Array.isArray(girFuncs))
-            for (const girFunc of girFuncs) {
-                if (girFunc?.$?.name) {
-                    // girFunc._girType = girType
-                    // girFunc._tsType = tsType
-                    girFunc._class = girClass;
-                    const nsName = girClass ? girClass._fullSymName : this.namespace;
-                    if (nsName)
-                        girFunc._fullSymName = `${nsName}.${girFunc.$.name}`;
-                    this.annotateFunctionArguments(girFunc);
-                    this.annotateFunctionReturn(girFunc);
-                }
-            }
-    }
-    /**
-     * Variables which are not part of a class
-     */
-    annotateVariables(girVars) {
-        for (const girVar of girVars) {
-            girVar._module = this;
-            if (girVar.$ && girVar.$.name) {
-                girVar._fullSymName = `${this.namespace}.${girVar.$.name}`;
-            }
+    get members() {
+        if (!this._members) {
+            this._members = new Map();
         }
+        return this._members;
     }
-    /**
-     * Fields are variables which are part of a class
-     * @see https://www.typescriptlang.org/docs/handbook/2/classes.html#fields
-     */
-    annotateFields(girClass, girVars) {
-        for (const girVar of girVars) {
-            const nsName = girClass ? girClass._fullSymName : this.namespace;
-            girVar._module = this;
-            if (girClass) {
-                girVar._class = girClass;
-            }
-            if (girVar.$ && girVar.$.name && nsName) {
-                girVar._fullSymName = `${nsName}.${girVar.$.name}`;
-            }
-        }
-    }
-    annotateClass(girClass) {
-        girClass._module = this;
-        girClass._fullSymName = `${this.namespace}.${girClass.$.name}`;
-        const constructors = Array.isArray(girClass.constructor) ? girClass.constructor : [];
-        const signals = (girClass.signal ||
-            girClass['glib:signal'] ||
-            []);
-        const functions = girClass.function || [];
-        const methods = girClass.method || [];
-        const vMethods = girClass['virtual-method'] || new Array();
-        const properties = girClass.property;
-        const fields = girClass.field;
-        this.annotateMethods(girClass, constructors);
-        this.annotateMethods(girClass, functions);
-        this.annotateMethods(girClass, methods);
-        this.annotateMethods(girClass, vMethods);
-        this.annotateMethods(girClass, signals);
-        if (properties)
-            this.annotateFields(girClass, properties);
-        if (fields)
-            this.annotateFields(girClass, fields);
-    }
-    /**
-     * Annotates the custom `_module`, `_fullSymName` and `_girType` properties.
-     * Also registers the element on the `symTable`.
-     * @param girElements
-     * @param girType
-     */
-    annotateAndRegisterGirElement(girElements) {
-        for (const girElement of girElements) {
-            if (girElement?.$ && girElement.$.name) {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
-                if (!girElementIsIntrospectable(girElement))
-                    continue;
-                girElement._module = this;
-                girElement._fullSymName = `${this.namespace}.${girElement.$.name}`;
-                if (this.symTable.get(this.allDependencies, girElement._fullSymName)) {
-                    this.log.warn(WARN_DUPLICATE_SYMBOL(girElement._fullSymName));
-                }
-                this.symTable.set(this.allDependencies, girElement._fullSymName, girElement);
-            }
+    get enum_constants() {
+        if (!this._enum_constants) {
+            this._enum_constants = new Map();
         }
+        return this._enum_constants;
     }
-    /**
-     * TODO: find better name for this method
-     * @param girVar
-     * @param fullTypeName
-     * @returns e.g.
-     * ```ts
-     * {
-     *      namespace: "Gtk",
-     *      resValue: "Gtk.Widget"
-     * }
-     *
-     */
-    fullTypeLookup(girVar, fullTypeName) {
-        let resValue = '';
-        let namespace = '';
-        if (!fullTypeName) {
-            return {
-                value: resValue,
-                fullTypeName,
-                namespace,
-            };
-        }
-        // Fully qualify our type name
-        if (!fullTypeName.includes('.')) {
-            let tryFullTypeName = '';
-            if (!resValue && girVar._module && girVar._module !== this) {
-                tryFullTypeName = `${girVar._module.namespace}.${fullTypeName}`;
-                resValue = this.fullTypeLookupWithNamespace(tryFullTypeName).value;
-                if (resValue) {
-                    fullTypeName = tryFullTypeName;
-                    namespace = girVar._module.namespace;
-                }
-            }
-            if (!resValue) {
-                tryFullTypeName = `${this.namespace}.${fullTypeName}`;
-                resValue = this.fullTypeLookupWithNamespace(tryFullTypeName).value;
-                if (resValue) {
-                    fullTypeName = tryFullTypeName;
-                    namespace = this.namespace;
-                }
-            }
-            const girClass = girVar._class;
-            if (!resValue && girClass?._module?.namespace && girClass._module !== this) {
-                tryFullTypeName = `${girClass._module.namespace}.${fullTypeName}`;
-                resValue = this.fullTypeLookupWithNamespace(tryFullTypeName).value;
-                if (resValue) {
-                    fullTypeName = tryFullTypeName;
-                    namespace = girClass?._module?.namespace;
-                }
-            }
-        }
-        if (!resValue && fullTypeName) {
-            resValue = this.fullTypeLookupWithNamespace(fullTypeName).value;
-        }
-        return {
-            value: resValue,
-            namespace,
-        };
-    }
-    /**
-     * this method needs to be refactored, an array can also be an array of an array for example
-     * @param girVar
-     * @returns
-     */
-    getArrayData(girVar) {
-        let arrayType = null;
-        let arrCType;
-        let isArray = false;
-        let overrideTypeName;
-        let typeArray;
-        let collection;
-        if (girVar.array) {
-            collection = girVar.array;
-        }
-        else if (/^GLib.S?List$/.test(girVar.type?.[0].$?.name || '')) {
-            // This converts GLib.List<T> / GLib.SList<T> to T[]
-            collection = girVar.type;
-        }
-        if (collection && collection.length > 0) {
-            isArray = true;
-            typeArray = collection[0].type;
-            if (collection[0].$) {
-                const ea = collection[0].$;
-                arrCType = ea['c:type'];
-            }
-        }
-        if (typeArray && typeArray?.length > 0) {
-            arrayType = typeArray[0];
-        }
-        if (this.config.environment == 'gjs' && isArray && arrayType?.$?.name && ARRAY_TYPE_MAP[arrayType.$.name]) {
-            isArray = false;
-            overrideTypeName = ARRAY_TYPE_MAP[arrayType.$.name];
-        }
-        return {
-            arrCType,
-            arrayType,
-            isArray,
-            overrideTypeName,
-        };
-    }
-    /**
-     * Get the typescript type of a GirElement like a `GirPropertyElement` or `GirCallableReturn`
-     * @param girVar
-     */
-    getTsType(girVar, tsClass, girTypeName, defaults = {}) {
-        let type = girVar.type?.[0];
-        let fullTypeName = null;
-        let typeName = defaults.type || '';
-        let isFunction = defaults.isFunction || false;
-        let isCallback = defaults.isCallback || false;
-        const nullable = this.typeIsNullable(girVar, girTypeName) || defaults.nullable || false;
-        const optional = this.typeIsOptional(girVar, girTypeName) || defaults.optional || false;
-        const girCallbacks = [];
-        const array = this.getArrayData(girVar);
-        if (array.overrideTypeName) {
-            typeName = array.overrideTypeName;
-        }
-        if (array.arrayType) {
-            type = array.arrayType;
-        }
-        const cType = type?.$ ? type.$['c:type'] : array.arrCType;
-        fullTypeName = type?.$?.name || null;
-        const callbacks = girVar.callback;
-        if (!typeName && callbacks?.length) {
-            for (const girCallback of callbacks) {
-                if (!girElementIsIntrospectable(girCallback))
-                    continue;
-                if (!girCallback._tsData) {
-                    const tsCallback = this.getFunctionTsData(girCallback, 'callback', tsClass, {
-                        isStatic: false,
-                        isArrowType: true,
-                        isGlobal: false,
-                        isVirtual: false,
-                        returnType: null,
-                        generics: [],
-                    });
-                    if (!tsCallback)
-                        continue;
-                    girCallback._tsData = {
-                        ...tsCallback,
-                        girTypeName: 'callback',
-                        tsTypeName: this.girFactory.girTypeNameToTsTypeName('callback', false),
-                        tsCallbackInterface: this.getCallbackInterfaceTsData(girCallback),
-                        doc: this.getTsDoc(girCallback),
-                        overloads: [],
-                    };
-                }
-                if (girCallback._tsData) {
-                    girCallbacks.push(girCallback);
-                    isFunction = true;
-                    isCallback = true;
-                }
-            }
-        }
-        if (!isFunction) {
-            const res = this.fullTypeLookup(girVar, fullTypeName);
-            if (res.value) {
-                typeName = res.value;
-                fullTypeName = typeName;
+    accept(visitor) {
+        for (const key of [...this.members.keys()]) {
+            const member = this.members.get(key);
+            if (!member)
+                continue;
+            if (Array.isArray(member)) {
+                this.members.set(key, member.map((m) => {
+                    return m.accept(visitor);
+                }));
             }
-        }
-        if (!typeName && type?.$?.name && PRIMITIVE_TYPE_MAP[type.$.name]) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            typeName = PRIMITIVE_TYPE_MAP[type.$.name];
-        }
-        if (cType) {
-            const parsedCType = PRIMITIVE_TYPE_MAP[cType];
-            if (!typeName && parsedCType) {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                typeName = parsedCType;
+            else {
+                this.members.set(key, member.accept(visitor));
             }
         }
-        if (!typeName) {
-            typeName = 'any';
-            const logName = cType || fullTypeName || girVar.$.name || '';
-            this.log.warn(WARN_NOT_FOUND_TYPE(logName));
-        }
-        // TODO: transform array to type with generics?
-        const tsType = this.girFactory.newTsType({
-            ...defaults,
-            type: typeName,
-            optional,
-            nullable,
-            callbacks: girCallbacks,
-            isArray: array.isArray,
-            isFunction,
-            isCallback,
-        });
-        return tsType;
+        return this;
     }
-    /**
-     *
-     * @param girFunc
-     * @returns
-     */
-    getReturnType(girFunc, tsClass, generics = []) {
-        const girTypeName = 'callable-return';
-        let outArrayLengthIndex = -1;
-        if (girFunc['return-value'] && girFunc['return-value'].length > 1) {
-            throw new Error('Several return values found!');
-        }
-        // There are no multiple return values, so we always use index 0
-        const girVar = girFunc['return-value']?.[0] || null;
-        // We still use an array to allow multiple return values for later
-        const returnTypes = [];
-        if (girVar) {
-            returnTypes.push(this.getTsType(girVar, tsClass, girTypeName, { generics }));
-            outArrayLengthIndex = girVar.array && girVar.array[0].$?.length ? Number(girVar.array[0].$.length) : -1;
-        }
-        else {
-            returnTypes.push(this.girFactory.newTsType({ type: 'void', generics }));
-        }
-        const retTypeIsVoid = returnTypes.length === 1 && returnTypes[0].type === 'void';
-        return { returnTypes, outArrayLengthIndex, retTypeIsVoid };
-    }
-    arrayLengthIndexLookup(girVar) {
-        if (!girVar.array)
-            return -1;
-        const arr = girVar.array[0];
-        if (!arr.$)
-            return -1;
-        if (arr.$.length) {
-            return parseInt(arr.$.length);
-        }
-        return -1;
-    }
-    closureDataIndexLookup(girVar) {
-        if (!girVar.$.closure)
-            return -1;
-        return parseInt(girVar.$.closure);
-    }
-    destroyDataIndexLookup(girVar) {
-        if (!girVar.$.destroy)
-            return -1;
-        return parseInt(girVar.$.destroy);
-    }
-    processParams(params, skip, getIndex) {
-        for (const param of params) {
-            const index = getIndex(param);
-            if (index < 0)
-                continue;
-            if (index >= params.length)
-                continue;
-            skip.push(params[index]);
-        }
+    getImportsForCPrefix(c_prefix) {
+        return this.parent.namespacesForPrefix(c_prefix);
     }
-    /**
-     * Checks if the parameter is nullable (which results in ` | null`).
-     *
-     * @param girVar girVar to test
-     */
-    typeIsNullable(girVar, girTypeName) {
-        const a = girVar.$;
-        if (!a)
-            return false;
-        const type = girVar.type?.[0];
-        const cType = type?.$?.['c:type'];
-        // Ignore depreciated `allow-none` if one of the new implementation `optional` or `nullable` is set
-        if (a.optional || a.nullable) {
-            return girBool(a.nullable);
-        }
-        if (girTypeName === 'constant') {
-            return false; // constants are never nullable
-        }
-        // UTF-8 string pointers can be null, e.g. `gchar*`, see https://github.com/gjsify/ts-for-gir/issues/108
-        if (type?.$?.name === 'utf8' && !cType?.startsWith('const ') && cType?.endsWith('*')) {
-            return true;
-        }
-        // If the default value is NULL, handle this as nullable
-        if (a['default-value'] === 'NULL') {
-            return true;
-        }
-        return girBool(a.nullable) || girBool(a['allow-none']) || girBool(a['null-ok']);
+    // TODO: Move this into the generator
+    hasImport(name) {
+        return this.dependencies.some((dep) => dep.importName === name);
     }
-    /**
-     * Checks if the parameter is optional (which results in `foo?: bar`).
-     * @param girVar girVar to test
-     */
-    typeIsOptional(girVar, girTypeName) {
-        const a = girVar.$;
-        if (!a)
-            return false;
-        // Ignore depreciated `allow-none` if one of the new implementation `optional` or `nullable` is set
-        if (a.optional || a.nullable) {
-            return girBool(a.optional);
+    _getImport(name) {
+        if (name === this.name) {
+            return this;
         }
-        if (girTypeName === 'constant') {
-            return false; // constants are never optional
-        }
-        return girBool(a.optional) || girBool(a['allow-none']) || girBool(a['null-ok']);
-    }
-    /**
-     * Checks if the property is readonly.
-     * @param girCallback
-     */
-    typeIsReadonly(girProp) {
-        const cType = girProp.type?.[0].$?.['c:type'];
-        return (!girBool(girProp.$.writable) ||
-            girBool(girProp.$['construct-only']) ||
-            (cType ? cType.startsWith('const ') : false) // c type is const and therefore readonly, isn't?
-        );
-    }
-    setParameterTsData(girParam, girParams, paramNames, skip, parent) {
-        const girTypeName = 'callable-param';
-        // I think it's safest to force inout params to have the
-        // same type for in and out
-        const tsType = this.getTsType(girParam, parent.parent, girTypeName);
-        // const optDirection = girParam.$.direction
-        if (girParam._tsData) {
-            // this.log.warn('[setParameterTsData] _tsData already set!')
-            return girParam._tsData;
-        }
-        if (tsType.isCallback) {
-            throw new Error('Callback type is not implemented here');
-        }
-        let paramName = this.transformation.transformParameterName(girParam, false);
-        if (paramNames.includes(paramName)) {
-            this.log.warn(WARN_DUPLICATE_PARAMETER(paramName, girParam._fullSymName));
-            paramName += '_';
-        }
-        paramNames.push(paramName);
-        // In Typescript no optional parameters are allowed if the following ones are not optional
-        if (tsType.optional) {
-            const index = girParams.indexOf(girParam);
-            const following = girParams
-                .slice(index)
-                .filter(() => skip.indexOf(girParam) === -1)
-                .filter((p) => p.$.direction !== GirDirection.Out);
-            if (following.some((p) => !this.typeIsOptional(p, girTypeName))) {
-                tsType.optional = false;
+        const dep = this.dependencies.find((dep) => dep.namespace === name) ??
+            this.transitiveDependencies.find((dep) => dep.namespace === name);
+        // Handle finding imports via their other prefixes
+        if (!dep) {
+            this.log.info(`Failed to find namespace ${name} in dependencies, resolving via c:prefixes`);
+            // TODO: It might make more sense to move this conversion _before_
+            // the _getImport call.
+            const resolvedNamespaces = this.dependencyManager.namespacesForPrefix(name);
+            if (resolvedNamespaces.length > 0) {
+                this.log.info(`Found namespaces for prefix ${name}: ${resolvedNamespaces.map((r) => `${r.name} (${r.version})`).join(', ')}`);
             }
-        }
-        const tsParam = {
-            name: paramName,
-            type: [tsType],
-            isRest: false,
-            girTypeName,
-            doc: this.getTsDoc(girParam),
-            parent,
-        };
-        girParam._tsData = tsParam;
-        // // TODO: remove this, wee need a special solution for Gio.AsyncReadyCallback instead
-        girParam = this.inject.toParameterType(girParam);
-        return girParam._tsData;
-    }
-    getInstanceParameterTsData(instanceParameter) {
-        const typeName = instanceParameter.type?.[0]?.$?.name || undefined;
-        const rec = typeName ? this.ns.record?.find((r) => r.$.name == typeName) : undefined;
-        const structFor = rec?.$['glib:is-gtype-struct-for'];
-        if (structFor && instanceParameter.$.name) {
-            // TODO: Should use of a constructor, and even of an instance, be discouraged?
-            return {
-                name: instanceParameter.$.name,
-                structFor,
-            };
-        }
-        return undefined;
-    }
-    setParametersTsData(outArrayLengthIndex, girParams = [], parent) {
-        const outParams = [];
-        const inParams = [];
-        const paramNames = [];
-        const instanceParameters = [];
-        if (girParams && girParams.length > 0) {
-            for (const girParam of girParams) {
-                const params = girParam?.parameter || [];
-                // Instance parameter needs to be exposed for class methods (see comment above getClassMethods())
-                const instanceParameter = girParams[0]['instance-parameter']?.[0];
-                if (instanceParameter) {
-                    instanceParameter._tsData = this.getInstanceParameterTsData(instanceParameter);
-                    if (instanceParameter._tsData) {
-                        instanceParameters.push(instanceParameter);
-                    }
+            for (const resolvedNamespace of resolvedNamespaces) {
+                if (resolvedNamespace.name === this.name && resolvedNamespace.version === this.version) {
+                    return this;
                 }
-                if (params.length) {
-                    const skip = outArrayLengthIndex === -1 ? [] : [params[outArrayLengthIndex]];
-                    this.processParams(params, skip, (girVar) => this.arrayLengthIndexLookup(girVar));
-                    this.processParams(params, skip, (girVar) => this.closureDataIndexLookup(girVar));
-                    this.processParams(params, skip, (girVar) => this.destroyDataIndexLookup(girVar));
-                    for (const param of params) {
-                        if (skip.includes(param)) {
-                            continue;
-                        }
-                        param._tsData = this.setParameterTsData(param, params, paramNames, skip, parent);
-                        const optDirection = param.$.direction;
-                        if (optDirection === GirDirection.Out ||
-                            optDirection === GirDirection.Inout ||
-                            optDirection === GirDirection.InOut) {
-                            outParams.push(param);
-                            if (optDirection === GirDirection.Out)
-                                continue;
-                        }
-                        inParams.push(param);
-                    }
+                const dep = this.dependencies.find((dep) => dep.namespace === resolvedNamespace.name && dep.version === resolvedNamespace.version) ??
+                    this.transitiveDependencies.find((dep) => dep.namespace === resolvedNamespace.name && dep.version === resolvedNamespace.version);
+                if (dep) {
+                    return this.parent.namespace(resolvedNamespace.name, dep.version);
                 }
             }
         }
-        return { outParams, paramNames, inParams, instanceParameters };
-    }
-    getVariableTsData(girVar, girTypeName, tsTypeName, tsClass, optional = false, nullable = false, allowQuotes = false, generics = []) {
-        if (!girVar.$.name)
-            return undefined;
-        if (!girVar ||
-            !girVar.$ ||
-            !girBool(girVar.$.introspectable, true) ||
-            girBool(girVar.$.private)) {
-            return undefined;
-        }
-        if (girVar._tsData) {
-            // this.log.warn('[getVariableTsData] _tsData already set!')
-            return girVar._tsData;
-        }
-        let name = girVar.$.name;
-        if (tsTypeName === 'constructor-property') {
-            name = this.transformation.transformConstructorPropertyName(girVar.$.name, allowQuotes);
+        let version = dep?.version;
+        if (!version) {
+            version = this.parent.assertDefaultVersionOf(name);
         }
-        else {
-            switch (girTypeName) {
-                case 'property':
-                    name = this.transformation.transformPropertyName(girVar.$.name, allowQuotes);
-                    break;
-                case 'constant':
-                    name = this.transformation.transformConstantName(girVar.$.name, allowQuotes);
-                    break;
-                case 'field':
-                    name = this.transformation.transformFieldName(girVar.$.name, allowQuotes);
-                    break;
-            }
-        }
-        // Use the out type because it can be a union which isn't appropriate
-        // for a property
-        const tsType = this.getTsType(girVar, tsClass, girTypeName, { optional, nullable, generics });
-        const tsData = {
-            name,
-            type: [tsType],
-            isInjected: false,
-            girTypeName,
-            tsTypeName,
-            doc: this.getTsDoc(girVar),
-        };
-        tsData.doc.tags.push(...this.getTsDocGirElementTags(tsData.tsTypeName, tsData.girTypeName));
-        return tsData;
+        return this.parent.namespace(name, version);
     }
-    /**
-     *
-     * @param girProp
-     * @param girTypeName
-     * @param tsTypeName
-     * @param construct construct means include the property even if it's construct-only,
-     * @param optional optional means if it's construct-only it will also be marked optional (?)
-     * @param nullable
-     * @returns
-     */
-    getPropertyTsData(girProp, girTypeName, tsTypeName, tsClass, construct = false, optional, nullable) {
-        if (!girBool(girProp.$.writable) && construct)
-            return undefined;
-        if (girBool(girProp.$.private))
-            return undefined;
-        if (girProp._tsData) {
-            // this.log.warn('[getPropertyTsData] _tsData already set!')
-            return girProp._tsData;
+    getInstalledImport(name) {
+        if (name === this.name) {
+            return this;
         }
-        if (optional === undefined)
-            optional = this.typeIsOptional(girProp, girTypeName);
-        if (nullable === undefined)
-            nullable = this.typeIsNullable(girProp, girTypeName);
-        const readonly = !construct && this.typeIsReadonly(girProp);
-        let tsData;
-        switch (girTypeName) {
-            case 'property':
-                tsData = this.getVariableTsData(girProp, girTypeName, tsTypeName, tsClass, construct && optional, construct && nullable, true);
-                break;
-            case 'field':
-                if (tsTypeName !== 'property') {
-                    throw new Error(`Wrong tsType: "${tsTypeName}" for girType: "${girTypeName}`);
-                }
-                tsData = this.getVariableTsData(girProp, girTypeName, tsTypeName, tsClass, construct && optional, construct && nullable, true);
-                break;
-            default:
-                throw new Error(`Unknown property type: ${girTypeName}`);
+        const dep = this.dependencies.find((dep) => dep.namespace === name) ??
+            this.transitiveDependencies.find((dep) => dep.namespace === name);
+        let version = dep?.version;
+        if (!version) {
+            version = this.parent.defaultVersionOf(name) ?? undefined;
         }
-        if (!tsData?.name) {
-            return undefined;
+        if (!version) {
+            return null;
         }
-        tsData = {
-            ...tsData,
-            readonly,
-        };
-        return tsData;
+        const namespace = this.parent.namespace(name, version);
+        return namespace;
     }
-    /**
-     *
-     * @param girFunc
-     * @param prefix E.g. vfunc
-     * @param overrideReturnType
-     * @param isArrowType
-     * @param indentCount
-     */
-    getFunctionTsData(girFunc, girTypeName, tsClass, overwrite) {
-        if (!girFunc || !girFunc.$ || !girBool(girFunc.$.introspectable, true) || girFunc.$['shadowed-by']) {
-            return undefined;
+    assertInstalledImport(name) {
+        const namespace = this._getImport(name);
+        if (!namespace) {
+            throw new Error(`Failed to import ${name} in ${this.name}, not installed or accessible.`);
         }
-        let hasUnresolvedConflict;
-        // TODO: Fix that we overwrite tsData every time seems wrong to me, but if I just return the already defined `_tsData` leads to problems with the overload methods
-        if (girFunc._tsData) {
-            hasUnresolvedConflict = girFunc._tsData?.hasUnresolvedConflict; // WORKAROUND do not overwrite conflicts
-        }
-        let name = girFunc.$.name;
-        const { returnTypes, outArrayLengthIndex, retTypeIsVoid } = this.getReturnType(girFunc, tsClass);
-        const shadows = girFunc.$.shadows;
-        if (shadows) {
-            name = shadows;
+        return namespace;
+    }
+    getMembers(name) {
+        const members = this.members.get(name);
+        if (Array.isArray(members)) {
+            return [...members];
         }
-        // Overwrites
-        overwrite.isStatic = overwrite.isStatic || girTypeName === 'static-function' || girTypeName === 'constructor';
-        overwrite.isGlobal = overwrite.isGlobal || girTypeName === 'function';
-        overwrite.isVirtual = overwrite.isVirtual || girTypeName === 'virtual';
-        overwrite.isInjected = overwrite.isInjected || false;
-        // Function name transformation by environment
-        name = this.transformation.transformFunctionName(name, overwrite.isVirtual);
-        const tsData = {
-            isArrowType: overwrite.isArrowType,
-            isStatic: overwrite.isStatic,
-            isGlobal: overwrite.isGlobal,
-            isVirtual: overwrite.isVirtual,
-            isInjected: overwrite.isInjected,
-            returnTypes,
-            retTypeIsVoid,
-            name,
-            overrideReturnType: overwrite.returnType || undefined,
-            inParams: [],
-            outParams: [],
-            instanceParameters: [],
-            generics: overwrite.generics,
-            hasUnresolvedConflict,
-            girTypeName: girTypeName,
-            tsTypeName: this.girFactory.girTypeNameToTsTypeName(girTypeName, overwrite.isStatic),
-            doc: this.getTsDoc(girFunc),
-            overloads: [],
-            parent: tsClass,
-        };
-        const { inParams, outParams, instanceParameters } = this.setParametersTsData(outArrayLengthIndex, girFunc.parameters, tsData);
-        tsData.inParams.push(...inParams);
-        tsData.outParams.push(...outParams);
-        tsData.instanceParameters.push(...instanceParameters);
-        tsData.doc.tags.push(...this.getTsDocGirElementTags(tsData.tsTypeName, tsData.girTypeName));
-        tsData.doc.tags.push(...this.getTsDocInParamTags(tsData?.inParams));
-        tsData.doc.tags.push(...this.getTsDocReturnTags(girFunc));
-        return tsData;
+        return members ? [members] : [];
     }
-    overloadPromisifiedFunctions(girFunctions) {
-        if (!this.config.promisify)
-            return;
-        const promisifyAsyncReturn = ['Gio.AsyncReadyCallback', 'AsyncReadyCallback'];
-        const promisifyFuncMap = {};
-        // Find the functions that can be promisified
-        for (const girFunction of girFunctions) {
-            const tsFunction = girFunction._tsData;
-            if (!tsFunction)
-                continue;
-            // Check if function name satisfies async,finish scheme
-            const isAsync = tsFunction.name.endsWith('_async') || tsFunction.name.endsWith('_begin');
-            const isFinish = tsFunction.name.endsWith('_finish');
-            if (!isAsync && !isFinish)
-                continue;
-            // Handle async functions
-            if (isAsync) {
-                if (tsFunction.inParams.length === 0)
-                    continue;
-                const lastParam = tsFunction.inParams[tsFunction.inParams.length - 1];
-                if (lastParam.type && lastParam.type.length > 0) {
-                    const type = lastParam.type[0].$.name;
-                    if (type && promisifyAsyncReturn.includes(type)) {
-                        if (!(tsFunction.name in promisifyFuncMap))
-                            promisifyFuncMap[tsFunction.name] = {};
-                        promisifyFuncMap[tsFunction.name].asyncFn = tsFunction;
-                    }
-                }
-            }
-            // Handle finish functions
-            if (isFinish) {
-                if (tsFunction.returnTypes.length === 0)
-                    continue;
-                let name = `${tsFunction.name.replace(/(_finish)$/, '')}_async`;
-                if (!(name in promisifyFuncMap))
-                    name = `${tsFunction.name.replace(/(_finish)$/, '')}_begin`;
-                if (!(name in promisifyFuncMap))
-                    promisifyFuncMap[name] = {};
-                promisifyFuncMap[name].finishFn = tsFunction;
+    getMemberWithoutOverrides(name) {
+        if (this.members.has(name)) {
+            const member = this.members.get(name);
+            if (!Array.isArray(member)) {
+                return member;
             }
+            return null;
         }
-        // Generate TsFunctions for promisify-able functions and add to the array
-        for (const [, func] of Object.entries(promisifyFuncMap)) {
-            if (!func.asyncFn || !func.finishFn)
-                continue;
-            const inParams = this.girFactory.newGirCallableParamElements(func.asyncFn.inParams.slice(0, -1), func.asyncFn);
-            const outParams = this.girFactory.newGirCallableParamElements(func.finishFn.outParams, func.asyncFn);
-            const returnTypes = this.girFactory.newTsTypes(outParams.length > 0 ? [] : func.finishFn.returnTypes);
-            let docReturnText = func.finishFn.doc.tags.find((tag) => tag.tagName === 'returns')?.text || '';
-            if (docReturnText) {
-                docReturnText = `A Promise of: ${docReturnText}`;
-            }
-            else {
-                docReturnText = `A Promise of the result of {@link ${func.asyncFn.name}}`;
+        const resolvedName = this._resolve_names.get(name);
+        if (resolvedName) {
+            const member = this.members.get(resolvedName.name);
+            if (!Array.isArray(member)) {
+                return member;
             }
-            const docText = `Promisified version of {@link ${func.asyncFn.name}}\n\n${func.asyncFn.doc.text}`;
-            const docTags = func.asyncFn.doc.tags.filter((tag) => tag.paramName !== 'callback' && tag.paramName !== 'returns');
-            docTags.push({
-                tagName: 'returns',
-                text: docReturnText,
-                paramName: '',
-            });
-            const doc = this.girFactory.newTsDoc({
-                text: docText,
-                tags: docTags,
-            });
-            const promisifyFn = this.girFactory.newTsFunction({
-                ...func.asyncFn,
-                inParams,
-                outParams,
-                returnTypes,
-                isPromise: true,
-                doc,
-            }, func.asyncFn.parent);
-            func.asyncFn.overloads.push(promisifyFn);
         }
+        return null;
     }
-    getCallbackInterfaceTsData(girCallback) {
-        if (!girElementIsIntrospectable(girCallback))
-            return undefined;
-        const namespace = this.namespace;
-        const tsDataInterface = {
-            name: `${namespace}.${girCallback.$.name}`,
-            generics: [],
-        };
-        return tsDataInterface;
-    }
-    setCallbackTsData(girCallback, tsClass) {
-        const tsFunction = this.getFunctionTsData(girCallback, 'callback', tsClass, {
-            isStatic: false,
-            isArrowType: true,
-            isGlobal: false,
-            isVirtual: false,
-            returnType: null,
-            generics: [],
-        });
-        if (tsFunction) {
-            const tsCallback = {
-                ...tsFunction,
-                girTypeName: 'callback',
-                tsTypeName: this.girFactory.girTypeNameToTsTypeName('callback', false),
-                tsCallbackInterface: this.getCallbackInterfaceTsData(girCallback),
-                overloads: [],
-            };
-            girCallback._tsData = tsCallback;
-            this.inject.toCallback(girCallback);
+    assertClass(name) {
+        const clazz = this.getClass(name);
+        if (!clazz) {
+            throw new Error(`Class ${name} does not exist in namespace ${this.name}.`);
         }
-        return girCallback._tsData;
+        return clazz;
     }
-    getSignalCallbackInterfaceTsData(girCallback, girClass) {
-        if (!girElementIsIntrospectable(girCallback))
-            return undefined;
-        if (!girClass._tsData || !girClass._module) {
-            throw new Error(NO_TSDATA('getSignalCallbackTsData'));
-        }
-        const className = girClass._tsData.name;
-        const signalName = girCallback.$.name;
-        const signalInterfaceName = this.transformation.transformSignalInterfaceName(signalName);
-        const namespace = girClass._module.namespace;
-        const tsDataInterface = {
-            name: `${namespace}.${className}.${signalInterfaceName}SignalCallback`,
-            generics: [],
-            overwriteDoc: {
-                text: `Signal callback interface for \`${signalName}\``,
-                tags: [],
-            },
-        };
-        return tsDataInterface;
-    }
-    getConstructorFunctionTsData(parentClass, girConstructor) {
-        if (!girElementIsIntrospectable(girConstructor))
-            return;
-        const constructorTypeName = addNamespace(parentClass.name, parentClass.namespace);
-        return this.getFunctionTsData(girConstructor, 'constructor', parentClass, {
-            isStatic: true,
-            isArrowType: false,
-            isGlobal: false,
-            isVirtual: false,
-            returnType: constructorTypeName,
-            generics: [],
-        });
-    }
-    getSignalCallbackTsData(girSignalFunc, girClass) {
-        if (!girClass._tsData) {
-            throw new Error(NO_TSDATA('getSignalCallbackTsData'));
-        }
-        if (girSignalFunc._tsData) {
-            return girSignalFunc._tsData;
-        }
-        // Leads to errors here
-        // if (!girElementIsIntrospectable(girSignalFunc)) return undefined
-        const name = this.transformation.transform('signalName', girSignalFunc.$.name);
-        const { returnTypes, outArrayLengthIndex, retTypeIsVoid } = this.getReturnType(girSignalFunc, girClass._tsData);
-        if (this.config.environment === 'node') {
-            returnTypes[0].type === 'void';
+    getClass(name) {
+        const member = this.getMemberWithoutOverrides(name);
+        if (member instanceof IntrospectedBaseClass) {
+            return member;
         }
-        const tsCallback = {
-            name,
-            returnTypes,
-            isArrowType: true,
-            isStatic: false,
-            isGlobal: false,
-            isVirtual: false,
-            isInjected: false,
-            retTypeIsVoid,
-            inParams: [],
-            instanceParameters: [],
-            outParams: [],
-            generics: [],
-            girTypeName: 'callback',
-            tsTypeName: this.girFactory.girTypeNameToTsTypeName('callback', false),
-            doc: this.getTsDoc(girSignalFunc),
-            overloads: [],
-            parent: girClass._tsData,
-        };
-        const { inParams, outParams, instanceParameters } = this.setParametersTsData(outArrayLengthIndex, girSignalFunc.parameters, tsCallback);
-        if (this.config.environment === 'gjs') {
-            inParams.unshift(this.girFactory.newGirCallableParamElement({
-                name: '$obj',
-                type: [
-                    {
-                        type: girClass._tsData.name,
-                    },
-                ],
-            }, tsCallback));
-        }
-        tsCallback.inParams.push(...inParams);
-        tsCallback.outParams.push(...outParams);
-        tsCallback.instanceParameters.push(...instanceParameters);
-        tsCallback.doc.tags.push(...this.getTsDocGirElementTags(tsCallback.tsTypeName, tsCallback.girTypeName));
-        tsCallback.doc.tags.push(...this.getTsDocInParamTags(tsCallback?.inParams));
-        tsCallback.doc.tags.push(...this.getTsDocReturnTags(girSignalFunc));
-        return tsCallback;
+        return null;
     }
-    /**
-     * Generates signal methods like `connect`, `connect_after` and `emit` on Gjs or `connect`, `on`, `once`, `off` and `emit` an node-gtk
-     * for a default gir signal element
-     * @param girSignal
-     * @returns
-     */
-    getClassSignalMethodsTsData(girSignal, parentClass) {
-        if (!girSignal._tsData) {
-            throw new Error(NO_TSDATA('getClassSignalMethodsTsData'));
+    getEnum(name) {
+        const member = this.getMemberWithoutOverrides(name);
+        if (member instanceof IntrospectedEnum) {
+            return member;
         }
-        const inParams = girSignal._tsData.inParams.slice(1).map((inParam) => {
-            const injectParam = {
-                ...inParam._tsData,
-                type: inParam._tsData?.type || [],
-                name: inParam._tsData?.name || 'unknown',
-            };
-            return injectParam;
-        });
-        return this.girFactory.newTsSignalMethods(girSignal._tsData?.name, girSignal._tsData?.tsCallbackInterface?.name, inParams, parentClass, this.config.environment, false);
+        return null;
     }
-    /**
-     * Generates signal methods for the GObject properties of a gir class element
-     * @param girClass
-     */
-    getClassPropertySignalsMethods(girClass) {
-        if (!girClass._tsData) {
-            throw new Error(NO_TSDATA('getClassPropertySignalsMethods'));
+    getAlias(name) {
+        const member = this.getMemberWithoutOverrides(name);
+        if (member instanceof IntrospectedAlias) {
+            return member;
         }
-        const tsMethods = [];
-        const propertyNames = this.getClassNonStaticPropertyNames(girClass);
-        const namespacePrefix = this.namespace === 'GObject' ? '' : 'GObject.';
-        // TODO: Signals: Generate SignalMethods instead of direct types
-        for (const propertyName of propertyNames) {
-            let callbackType = 'any';
-            if (this.config.environment === 'gjs') {
-                const objParam = `$obj: ${girClass._tsData.name}`;
-                // TODO: create arrowType object instead of a pure string type, see Pango-1.0.Pango.FontMapClass.load_font for an example
-                callbackType = `((${objParam}, pspec: ${namespacePrefix}ParamSpec) => void)`;
-            }
-            else if (this.config.environment === 'node') {
-                callbackType = `(...args: any[]) => void`;
-            }
-            tsMethods.push(...this.girFactory.newTsSignalMethods(`notify::${propertyName}`, callbackType, [], girClass._tsData, this.config.environment));
-        }
-        return tsMethods;
+        return null;
     }
-    getGeneralSignalsMethods(parentClass) {
-        return this.girFactory.newTsSignalMethods(undefined, undefined, [], parentClass, this.config.environment, true);
-    }
-    setSignalTsData(girSignal, girClass) {
-        if (!girClass._tsData) {
-            throw NO_TSDATA('setSignalTsData');
-        }
-        if (!girSignal._tsData) {
-            girSignal._tsData = {
-                ...this.getSignalCallbackTsData(girSignal, girClass),
-                tsCallbackInterface: this.getSignalCallbackInterfaceTsData(girSignal, girClass),
-                tsMethods: [],
-                girTypeName: 'signal',
-                tsTypeName: this.girFactory.girTypeNameToTsTypeName('signal', false),
-                doc: this.getTsDoc(girSignal),
-                overloads: [],
-            };
-            girSignal._tsData.doc.tags.push(...this.getTsDocGirElementTags(girSignal._tsData.tsTypeName, girSignal._tsData.girTypeName));
-            // TODO: this are the callback parameters
-            girSignal._tsData.doc.tags.push(...this.getTsDocInParamTags(girSignal._tsData?.inParams));
-            girSignal._tsData.doc.tags.push(...this.getTsDocReturnTags(girSignal));
-            if (!girSignal._tsData) {
-                throw NO_TSDATA('setSignalTsData');
-            }
-            girSignal._tsData.tsMethods = this.getClassSignalMethodsTsData(girSignal, girClass._tsData);
-        }
-        return girSignal._tsData;
+    hasSymbol(name) {
+        return this.members.has(name);
     }
-    fixEnumerationDuplicateIdentifier(girEnum) {
-        if (!girElementIsIntrospectable(girEnum))
-            return girEnum;
-        if (!girEnum._tsData) {
-            throw new Error(NO_TSDATA('fixEnumerationDuplicateIdentifier'));
+    resolveSymbolFromTypeName(name) {
+        const resolvedName = this._resolve_names.get(name);
+        if (!resolvedName) {
+            return null;
         }
-        if (!girEnum.member?.length) {
-            return girEnum;
+        const member = this.members.get(resolvedName.name);
+        if (member instanceof IntrospectedBase) {
+            return member.name;
         }
-        const memberNames = [];
-        for (const girEnumMember of girEnum.member) {
-            if (!girEnumMember._tsData) {
-                throw new Error(NO_TSDATA('fixEnumerationDuplicateIdentifier'));
-            }
-            if (memberNames.find((name) => name === girEnumMember._tsData?.name)) {
-                const renamed = '_' + girEnumMember._tsData.name;
-                this.log.warn(WARN_DUPLICATE_ENUM_IDENTIFIER(girEnumMember._tsData.name, renamed));
-                girEnumMember._tsData.name = renamed;
-            }
-            memberNames.push(girEnumMember._tsData.name);
-        }
-        return girEnum;
+        return null;
     }
-    getEnumerationMemberTsData(girEnumMember, girTypeName) {
-        const memberName = girEnumMember.$.name || girEnumMember.$['glib:nick'] || girEnumMember.$['c:identifier'];
-        if (!girElementIsIntrospectable(girEnumMember, memberName))
-            return undefined;
-        if (girEnumMember._tsData) {
-            // this.log.warn('[getEnumerationMemberTsData] _tsData already set!')
-            return girEnumMember._tsData;
+    findClassCallback(name) {
+        const clazzes = Array.from(this.members.values()).filter((m) => m instanceof IntrospectedBaseClass);
+        const res = clazzes
+            .map((m) => [m, m.callbacks.find((c) => c.name === name || c.resolve_names.includes(name))])
+            .find((r) => r[1] != null);
+        if (res) {
+            return [res[0].name, res[1].name];
         }
-        const name = this.transformation.transformEnumMember(memberName);
-        const tsData = {
-            name,
-            girTypeName,
-            tsTypeName: this.girFactory.girTypeNameToTsTypeName(girTypeName, false),
-            doc: this.getTsDoc(girEnumMember),
-        };
-        tsData.doc.tags.push(...this.getTsDocGirElementTags(tsData.tsTypeName, tsData.girTypeName));
-        return tsData;
-    }
-    getEnumerationTsData(girEnum, girTypeName) {
-        if (!girElementIsIntrospectable(girEnum))
-            return undefined;
-        if (girEnum._tsData) {
-            // this.log.warn('[getEnumerationMemberTsData] _tsData already set!')
-            return girEnum._tsData;
-        }
-        // E.g. the NetworkManager-1.0 has enum names starting with 80211
-        const name = this.transformation.transformEnumName(girEnum);
-        const tsData = {
-            name,
-            girTypeName,
-            tsTypeName: this.girFactory.girTypeNameToTsTypeName(girTypeName, false),
-            doc: this.getTsDoc(girEnum),
+        else {
+            return [null, name];
+        }
+    }
+    /**
+     * This is an internal method to add TypeScript <reference>
+     * comments when overrides use parts of the TypeScript standard
+     * libraries that are newer than default.
+     */
+    ___dts___addReference(reference) {
+        this.__dts__references ??= [];
+        this.__dts__references.push(reference);
+    }
+    static load(repo, config, registry) {
+        const ns = repo.repository[0]?.namespace?.[0];
+        if (!ns)
+            throw new Error(`Missing namespace in ${repo.repository[0].package[0].$.name}`);
+        const modName = ns.$['name'];
+        const version = ns.$['version'];
+        // TODO: Hardcoding HarfBuzz here leads to issues when loading...
+        // Hardcode harfbuzz version for now...
+        // if (modName === 'HarfBuzz' && version === '0.0') {
+        //     version = '2.0'
+        // }
+        const options = {
+            loadDocs: !config.noComments,
+            propertyCase: 'both',
+            verbose: config.verbose,
         };
-        tsData.doc.tags.push(...this.getTsDocGirElementTags(tsData.tsTypeName, tsData.girTypeName));
-        return tsData;
-    }
-    getAliasTsData(girAlias, tsClass) {
-        if (!girElementIsIntrospectable(girAlias))
-            return undefined;
-        const girTypeName = 'alias';
-        if (girAlias._tsData) {
-            // this.log.warn('[getEnumerationMemberTsData] _tsData already set!')
-            return girAlias._tsData;
-        }
-        const { type: typeName } = this.getTsType(girAlias, tsClass, girTypeName);
-        const name = girAlias.$.name;
-        const tsData = {
-            name,
-            type: typeName,
-            girTypeName,
-            tsTypeName: this.girFactory.girTypeNameToTsTypeName(girTypeName, false),
+        if (!modName) {
+            throw new Error('Invalid GIR file: no namespace name specified.');
+        }
+        if (!version) {
+            throw new Error('Invalid GIR file: no version name specified.');
+        }
+        const c_prefix = ns.$?.['c:identifier-prefixes']?.split(',') ?? [];
+        if (options.verbose) {
+            console.debug(`Parsing ${modName}...`);
+        }
+        const building = new GirModule(repo.repository[0], modName, version, c_prefix, config);
+        building.parent = registry;
+        // Set the namespace object here to prevent re-parsing the namespace if
+        // another namespace imports it.
+        registry.register(building);
+        const prefixes = repo.repository[0]?.$?.['c:identifier-prefixes']?.split(',');
+        const unknownPrefixes = prefixes?.filter((pre) => pre !== modName);
+        if (unknownPrefixes && unknownPrefixes.length > 0) {
+            console.log(`Found additional prefixes for ${modName}: ${unknownPrefixes.join(', ')}`);
+            building.prefixes.push(...unknownPrefixes);
+        }
+        const importConflicts = (el) => {
+            return !building.hasImport(el.name);
         };
-        return tsData;
-    }
-    getConstantTsData(girConst, tsClass) {
-        if (!girElementIsIntrospectable(girConst))
-            return undefined;
-        if (girConst._tsData) {
-            // this.log.warn('[getConstantTsData] _tsData already set!')
-            return girConst._tsData;
-        }
-        let tsData = this.getVariableTsData(girConst, 'constant', 'constant', tsClass, false, false, false);
-        if (tsData?.name) {
-            if (!this.constNames[tsData.name]) {
-                this.constNames[tsData.name] = girConst;
-            }
-            else {
-                this.log.warn(WARN_CONSTANT_ALREADY_EXPORTED(tsData.name));
-                tsData = undefined;
-            }
-        }
-        return tsData;
-    }
-    // FIXME: https://github.com/gjsify/ts-for-gir/issues/145
-    // FIXME: https://github.com/gjsify/ts-for-gir/issues/131
-    getClassConstructPropsTsData(girClass, constructPropNames) {
-        const constructProps = [];
-        const girProperties = girClass.property;
-        if (!girProperties?.length) {
-            return constructProps;
-        }
-        for (const girProp of girProperties) {
-            if (!girElementIsIntrospectable(girProp) || !girProp.$.name)
-                continue;
-            // Do not modify the original girProp, create a new one by clone `girProp` to `girConstrProp`
-            const girConstrProp = clone(girProp);
-            if (!girClass._tsData)
-                continue;
-            if (!girConstrProp._tsData) {
-                girConstrProp._tsData = this.getPropertyTsData(girConstrProp, 'property', 'constructor-property', girClass._tsData, true, true, true, 0);
-            }
-            if (!girConstrProp._tsData) {
-                continue;
-            }
-            const localName = this.checkOrSetLocalName(girConstrProp, constructPropNames, 'property');
-            if (!localName?.added) {
-                continue;
-            }
-            if (girConstrProp._fullSymName) {
-                this.symTable.set(this.allDependencies, girConstrProp._fullSymName, girConstrProp);
-            }
-            constructProps.push(girConstrProp);
-            // Clone property with the name in underscores, see https://github.com/gjsify/ts-for-gir/issues/138
-            // const underscoresProperty = this.clonePropertyForUnderscores(girConstrProp)
-            // if (underscoresProperty && underscoresProperty._fullSymName) {
-            //     girProperties.push(underscoresProperty)
-            //     this.symTable.set(this.allDependencies, underscoresProperty._fullSymName, underscoresProperty)
-            // }
-        }
-        return constructProps;
-    }
-    /**
-     * Some class/static methods are defined in a separate record which is not
-     * exported, but the methods are available as members of the JS constructor.
-     * In gjs one can use an instance of the object, a JS constructor or a GType
-     * as the method's instance-parameter.
-     * @see https://discourse.gnome.org/t/using-class-methods-like-gtk-widget-class-get-css-name-from-gjs/4001
-     * @param girClass
-     */
-    getClassRecordMethods(girClass) {
-        const girMethods = [];
-        if (!girClass.$.name)
-            return girMethods;
-        const fName = girClass.$.name + 'Class';
-        let rec = this.ns.record?.find((r) => r.$.name == fName);
-        if (!rec || !this.isGtypeStructFor(girClass, rec)) {
-            rec = this.ns.record?.find((r) => this.isGtypeStructFor(girClass, r));
-            fName == rec?.$.name;
-        }
-        if (!rec)
-            return girMethods;
-        // Record methods
-        const methods = rec.method || [];
-        for (const girMethod of methods) {
-            if (!girElementIsIntrospectable(girMethod) || !girClass._tsData)
-                continue;
-            if (!girMethod._tsData)
-                girMethod._tsData = this.getFunctionTsData(girMethod, 'static-function', girClass._tsData, {
-                    isStatic: true,
-                    isArrowType: false,
-                    isGlobal: false,
-                    isVirtual: false,
-                    returnType: null,
-                    generics: [],
-                });
-            if (!girMethod._tsData)
-                continue;
-            if (girMethod._tsData) {
-                if (girMethod._fullSymName)
-                    this.symTable.set(this.allDependencies, girMethod._fullSymName, girMethod);
-                girMethods.push(girMethod);
-            }
-        }
-        this.overloadPromisifiedFunctions(methods);
-        return girMethods;
-    }
-    /**
-     * Instance methods
-     * @param girClass
-     * @param localNames
-     */
-    getClassMethodsTsData(girClass, localNames) {
-        const girMethods = [];
-        if (girClass.method) {
-            for (const girMethod of girClass.method) {
-                if (!girElementIsIntrospectable(girMethod) || !girClass._tsData)
-                    continue;
-                if (!girMethod._tsData)
-                    girMethod._tsData = this.getFunctionTsData(girMethod, 'method', girClass._tsData, {
-                        isStatic: false,
-                        isArrowType: false,
-                        isGlobal: false,
-                        isVirtual: false,
-                        returnType: null,
-                        generics: [],
-                    });
-                if (!girMethod._tsData)
-                    continue;
-                const localName = this.checkOrSetLocalName(girMethod, localNames, 'method');
-                if (localName?.added && localName.method) {
-                    if (girMethod._fullSymName)
-                        this.symTable.set(this.allDependencies, girMethod._fullSymName, girMethod);
-                    girMethods.push(localName.method);
-                }
-            }
-            this.overloadPromisifiedFunctions(girClass.method);
-        }
-        return girMethods;
-    }
-    getClassFieldsTsData(girClass, localNames) {
-        const girFields = [];
-        if (!girClass._tsData) {
-            this.log.warn(NO_TSDATA('setClassFieldsTsData'));
-            return girFields;
-        }
-        if (girClass.field) {
-            for (const girField of girClass.field) {
-                if (!girElementIsIntrospectable(girField))
-                    continue;
-                if (!girField._tsData)
-                    girField._tsData = this.getVariableTsData(girField, 'field', 'property', girClass._tsData, false, false, false);
-                if (!girField._tsData) {
-                    continue;
-                }
-                const localName = this.checkOrSetLocalName(girField, localNames, 'field');
-                if (localName?.added && localName.field) {
-                    if (girField._fullSymName)
-                        this.symTable.set(this.allDependencies, girField._fullSymName, girField);
-                    girFields.push(localName.field);
-                }
-            }
-        }
-        return girFields;
-    }
-    getGObjectProperties(girClass) {
-        const girProperties = [];
-        if (girClass._fullSymName && !STATIC_NAME_ALREADY_EXISTS.includes(girClass._fullSymName)) {
-            // Records, classes and interfaces all have a static name
-            const type = this.girFactory.newTsType({ type: 'string' });
-            const staticNameProp = this.girFactory.newGirProperty({
-                isStatic: true,
-                name: 'name',
-                type: [type],
-                girTypeName: 'property',
-            });
-            girProperties.push(staticNameProp);
-        }
-        if (girClass._tsData?.isDerivedFromGObject && girClass._module) {
-            if (this.config.environment === 'gjs') {
-                const type = this.girFactory.newTsType({
-                    // TODO: Type not as string
-                    type: 'GObject.GType',
-                    generics: this.girFactory.newGenerics([
-                        {
-                            value: girClass._tsData.name,
-                        },
-                    ]),
-                });
-                const staticGTypeProp = this.girFactory.newGirProperty({
-                    isStatic: true,
-                    name: '$gtype',
-                    type: [type],
-                    girTypeName: 'property',
-                });
-                girProperties.push(staticGTypeProp);
-            }
-            else if (this.config.environment === 'node') {
-                const staticGTypeProp = this.girFactory.newGirProperty({
-                    isStatic: false,
-                    name: '__gtype__',
-                    type: [{ type: 'number' }],
-                    girTypeName: 'property',
-                });
-                girProperties.push(staticGTypeProp);
-            }
-        }
-        return girProperties;
-    }
-    /**
-     * Create a clone object of a property with the name in upper camel case
-     * See github.com/gjsify/ts-for-gir/issues/138
-     * @param girProperty
-     * @returns
-     */
-    clonePropertyForUnderscores(girProperty) {
-        // Only for GJS
-        if (this.config.environment === 'node') {
-            return undefined;
-        }
-        const propertyName = girProperty._tsData?.name;
-        if (!propertyName) {
-            return undefined;
-        }
-        const underscoresPropertyName = underscores(propertyName);
-        // Nothing has changed
-        if (underscoresPropertyName === propertyName) {
-            return undefined;
-        }
-        const upperCamelCaseGirProperty = clone(girProperty);
-        upperCamelCaseGirProperty._tsData = clone(upperCamelCaseGirProperty._tsData);
-        if (!upperCamelCaseGirProperty._tsData) {
-            return undefined;
-        }
-        upperCamelCaseGirProperty._tsData.name = underscoresPropertyName;
-        upperCamelCaseGirProperty._fullSymName = upperCamelCaseGirProperty._fullSymName?.replace(propertyName, underscoresPropertyName);
-        return upperCamelCaseGirProperty;
-    }
-    getClassPropertiesTsData(girClass, localNames) {
-        const girProperties = [];
-        const properties = girClass.property;
-        if (properties) {
-            for (const girProperty of properties) {
-                if (!girElementIsIntrospectable(girProperty) || !girClass._tsData)
-                    continue;
-                girProperty._tsData = this.getPropertyTsData(girProperty, 'property', 'property', girClass._tsData);
-                if (!girProperty._tsData)
-                    continue;
-                {
-                    const localName = this.checkOrSetLocalName(girProperty, localNames, 'property');
-                    if (localName?.added && localName.property) {
-                        if (girProperty._fullSymName) {
-                            this.symTable.set(this.allDependencies, girProperty._fullSymName, girProperty);
-                        }
-                        girProperties.push(localName.property);
-                    }
-                }
-                // Add a new property with the name in lower camel case, see https://github.com/gjsify/ts-for-gir/issues/138
-                // {
-                //     const underscoresProperty = this.clonePropertyForUnderscores(girProperty)
-                //     if (underscoresProperty) {
-                //         const localName = this.checkOrSetLocalName(underscoresProperty, localNames, 'property')
-                //         if (localName?.added && localName.property) {
-                //             if (underscoresProperty._fullSymName) {
-                //                 this.symTable.set(
-                //                     this.allDependencies,
-                //                     underscoresProperty._fullSymName,
-                //                     underscoresProperty,
-                //                 )
-                //             }
-                //             girProperties.push(localName.property)
-                //         }
-                //     }
-                // }
-            }
-        }
-        return girProperties;
-    }
-    getClassNonStaticPropertyNames(girClass) {
-        const propertyNames = [];
-        if (!girClass._tsData) {
-            return propertyNames;
-        }
-        const girProperties = girClass._tsData.properties;
-        if (girProperties.length > 0) {
-            for (const girProperty of girProperties) {
-                if (!girElementIsIntrospectable(girProperty))
-                    continue;
-                if (girProperty.$.name &&
-                    !propertyNames.includes(girProperty.$.name) &&
-                    !girProperty._tsData?.isStatic) {
-                    propertyNames.push(girProperty.$.name);
-                }
-            }
-        }
-        // Extended property names
-        for (const fullSymName of Object.keys(girClass._tsData.inherit)) {
-            const girProperties = girClass._tsData.inherit[fullSymName]?.class.properties;
-            if (girProperties.length > 0) {
-                for (const girProperty of girProperties) {
-                    if (!girElementIsIntrospectable(girProperty))
-                        continue;
-                    if (girProperty.$.name &&
-                        !propertyNames.includes(girProperty.$.name) &&
-                        !girProperty._tsData?.isStatic) {
-                        propertyNames.push(girProperty.$.name);
-                    }
-                }
-            }
-        }
-        // Implemented property names
-        for (const fullSymName of Object.keys(girClass._tsData.implements)) {
-            const girProperties = girClass._tsData.implements[fullSymName]?.interface.properties;
-            if (girProperties.length > 0) {
-                for (const girProperty of girProperties) {
-                    if (!girElementIsIntrospectable(girProperty))
-                        continue;
-                    if (girProperty._tsData &&
-                        girProperty.$.name &&
-                        !propertyNames.includes(girProperty.$.name) &&
-                        !girProperty._tsData?.isStatic) {
-                        propertyNames.push(girProperty.$.name);
-                    }
-                }
-            }
-        }
-        return propertyNames;
-    }
-    getClassConstructorsTsData(girClass) {
-        if (!girClass._tsData) {
-            throw new Error(NO_TSDATA('getClassConstructorsTsData'));
-        }
-        const girConstructors = [];
-        // JS constructor(s)
-        if (girClass._tsData?.isDerivedFromGObject) {
-            const constructorInParam = {
-                name: 'config',
-                type: [
-                    {
-                        optional: true,
-                        type: girClass._tsData.constructPropInterfaceName,
-                    },
-                ],
-            };
-            const realConstructor = this.girFactory.newGirFunction({
-                name: 'constructor',
-                isStatic: true,
-                inParams: [constructorInParam],
-                girTypeName: 'constructor',
-            }, girClass._tsData);
-            const initConstructor = this.girFactory.newGirFunction({
-                name: '_init',
-                inParams: [constructorInParam],
-                girTypeName: 'method',
-            }, girClass._tsData);
-            girConstructors.push(realConstructor, initConstructor);
-        }
-        if (Array.isArray(girClass.constructor)) {
-            for (const girConstructor of girClass.constructor) {
-                if (!girElementIsIntrospectable(girConstructor))
-                    continue;
-                girConstructor._tsData = this.getConstructorFunctionTsData(girClass._tsData, girConstructor);
-                if (!girConstructor._tsData?.name)
-                    continue;
-                // Also add `new` pseudo constructors
-                const ADD_NEW_PSEUDO_CONSTRUCTOR = true;
-                // Inject an additional real constructor if static new(...) exists
-                if (girConstructor._tsData.name === 'new') {
-                    const realConstructor = clone(girConstructor);
-                    realConstructor._tsData = clone(realConstructor._tsData);
-                    if (realConstructor._tsData) {
-                        realConstructor._tsData.overloads = [];
-                        realConstructor.$.name = 'constructor';
-                        realConstructor._tsData.name = 'constructor';
-                        girConstructors.push(realConstructor);
-                    }
-                    if (ADD_NEW_PSEUDO_CONSTRUCTOR) {
-                        girConstructors.push(girConstructor);
-                    }
+        if (ns.enumeration) {
+            // Get the requested enums
+            ns.enumeration
+                ?.map((enumeration) => {
+                if (enumeration.$['glib:error-domain']) {
+                    return IntrospectedError.fromXML(enumeration, building, options);
                 }
                 else {
-                    girConstructors.push(girConstructor);
-                }
-            }
-        }
-        return girConstructors;
-    }
-    getClassVirtualMethodsTsData(girClass) {
-        const methods = girClass['virtual-method'] || [];
-        const girMethods = [];
-        for (const girVMethod of methods) {
-            if (!girElementIsIntrospectable(girVMethod) || !girClass._tsData)
-                continue;
-            girVMethod._tsData = this.getFunctionTsData(girVMethod, 'virtual', girClass._tsData, {
-                isStatic: false,
-                isArrowType: false,
-                isGlobal: false,
-                isVirtual: true,
-                returnType: null,
-                generics: [],
+                    return IntrospectedEnum.fromXML(enumeration, building, options);
+                }
+            })
+                .forEach((c) => building.members.set(c.name, c));
+        }
+        // Constants
+        if (ns.constant) {
+            ns.constant
+                ?.filter(isIntrospectable)
+                .map((constant) => IntrospectedConstant.fromXML(constant, building, options))
+                .filter(importConflicts)
+                .forEach((c) => building.members.set(c.name, c));
+        }
+        // Get the requested functions
+        if (ns.function) {
+            ns.function
+                ?.filter(isIntrospectable)
+                .map((func) => IntrospectedFunction.fromXML(func, building, options))
+                .filter(importConflicts)
+                .forEach((c) => building.members.set(c.name, c));
+        }
+        if (ns.callback) {
+            ns.callback
+                ?.filter(isIntrospectable)
+                .map((callback) => IntrospectedCallback.fromXML(callback, building, options))
+                .filter(importConflicts)
+                .forEach((c) => building.members.set(c.name, c));
+        }
+        if (ns['glib:boxed']) {
+            ns['glib:boxed']
+                ?.filter(isIntrospectable)
+                .map((boxed) => new IntrospectedAlias({
+                name: boxed.$['glib:name'],
+                namespace: building,
+                type: new NullableType(ObjectType),
+            }))
+                .forEach((c) => building.members.set(c.name, c));
+        }
+        // Bitfield is a type of enum
+        if (ns.bitfield) {
+            ns.bitfield
+                ?.filter(isIntrospectable)
+                .map((field) => IntrospectedEnum.fromXML(field, building, options, true))
+                .forEach((c) => building.members.set(c.name, c));
+        }
+        // The `enum_constants` map maps the C identifiers (GTK_BUTTON_TYPE_Y)
+        // to the name of the enum (Button) to resolve references (Gtk.Button.Y)
+        Array.from(building.members.values())
+            .filter((m) => m instanceof IntrospectedEnum)
+            .forEach((m) => {
+            m.members.forEach((member) => {
+                building.enum_constants.set(member.c_identifier, [m.name, member.name]);
             });
-            if (!girVMethod._tsData)
-                continue;
-            if (girVMethod?._tsData?.name) {
-                girMethods.push(girVMethod);
-            }
-        }
-        return girMethods;
-    }
-    /**
-     *
-     * @param girClass This is the class / interface the `parentClass` implements signals from
-     * @returns
-     */
-    getClassSignalsTsData(girClass) {
-        const girSignals = [];
-        const signals = girClass.signal ||
-            girClass['glib:signal'] ||
-            [];
-        if (signals) {
-            for (const girSignal of signals) {
-                girSignal._tsData = this.setSignalTsData(girSignal, girClass);
-                if (!girSignal._tsData)
-                    continue;
-                if (girSignal._fullSymName)
-                    this.symTable.set(this.allDependencies, girSignal._fullSymName, girSignal);
-                girSignals.push(girSignal);
-            }
-        }
-        return girSignals;
-    }
-    getClassParentObject(parentName, namespace, type) {
-        let qualifiedParentName;
-        let parentModName;
-        // WORKAROUND: Fix wrong parent names
-        if ((this.packageName === 'GstAudio-0.10' || this.packageName === 'ClutterGst-1.0') &&
-            (parentName === 'GstBase.BaseTransform' ||
-                parentName === 'GstBase.BaseSink' ||
-                parentName === 'GstBase.PushSrc')) {
-            const rename = parentName.replace('GstBase.', 'Gst.');
-            this.log.warn(`[getClassParentObject] Rename parent class "${parentName}" -> "${rename}"`);
-            parentName = rename;
-        }
-        if (parentName === 'GraniteServicesSettingsSerializable') {
-            parentName = 'ServicesSettingsSerializable';
-            this.log.warn(`[getClassParentObject] Rename parent class "GraniteServicesSettingsSerializable" -> "ServicesSettingsSerializable"`);
-        }
-        if (parentName.indexOf('.') < 0) {
-            qualifiedParentName = namespace + '.' + parentName;
-            parentModName = namespace;
-        }
-        else {
-            qualifiedParentName = parentName;
-            const split = parentName.split('.');
-            parentName = split[split.length - 1];
-            parentModName = split.slice(0, split.length - 1).join('.');
-        }
-        const localParentName = parentModName == namespace ? parentName : qualifiedParentName;
-        const dependencyExists = !!this.symTable.get(this.allDependencies, qualifiedParentName);
-        const cls = this.getClassParent({
-            qualifiedParentName,
-            parentName,
-        });
-        return {
-            qualifiedParentName,
-            localParentName,
-            type,
-            parentName,
-            cls,
-            dependencyExists,
-            // TODO: are there other types that can be inherited or implemented?
-            girTypeName: type === 'parent' ? 'class' : 'interface',
-        };
-    }
-    getClassParents(girClass) {
-        const parents = [];
-        if (!girClass._module?.namespace) {
-            throw new Error('Namespace not found!');
-        }
-        if (!girClass._tsData) {
-            throw new Error(NO_TSDATA('getClassParents'));
-        }
-        const prerequisites = girClass?.prerequisite;
-        const implmts = girClass?.implements;
-        if (implmts) {
-            for (const implement of implmts) {
-                const parentName = implement.$?.name;
-                if (!parentName)
-                    continue;
-                const parent = this.getClassParentObject(parentName, girClass._module.namespace, 'implements');
-                if (parent.dependencyExists) {
-                    parents.push(parent);
-                }
-            }
-        }
-        if (prerequisites) {
-            for (const prerequisite of prerequisites) {
-                const parentName = prerequisite.$?.name;
-                if (!parentName)
-                    continue;
-                const parent = this.getClassParentObject(parentName, girClass._module.namespace, 'prerequisite');
-                if (parent.dependencyExists) {
-                    parents.push(parent);
-                }
-            }
-        }
-        if (girClass.$.parent) {
-            const parentName = girClass.$.parent;
-            if (parentName) {
-                const parent = this.getClassParentObject(parentName, girClass._module.namespace, 'parent');
-                if (parent.dependencyExists) {
-                    parents.push(parent);
-                }
-            }
-        }
-        // Please reply: Do all interfaces always inherit from GObject.Object?
-        // If this is a interface and GObject.Object is not in the parents array, add GObject.Object to the parents
-        if (girClass._tsData.girTypeName === 'interface' && girClass._fullSymName !== 'GObject.Object') {
-            if (!parents.find((parent) => parent.qualifiedParentName === 'GObject.Object')) {
-                // TODO make sure this class exists in symTable
-                const gObjectObjectCls = this.symTable.getByHand('GObject-2.0.GObject.Object') || undefined;
-                const parent = {
-                    qualifiedParentName: 'GObject.Object',
-                    localParentName: girClass._module.namespace === 'GObject' ? 'Object' : 'GObject.Object',
-                    type: 'parent',
-                    parentName: 'Object',
-                    cls: gObjectObjectCls,
-                    dependencyExists: !!gObjectObjectCls,
-                    girTypeName: 'class',
-                };
-                if (parent.dependencyExists) {
-                    parents.push(parent);
-                }
-            }
-        }
-        return parents;
-    }
-    setClassBaseTsData(girClass, girTypeName) {
-        if (!girClass?.$?.name)
-            return undefined;
-        const girModule = girClass._module ? girClass._module : this;
-        let className = this.transformation.transformClassName(girClass.$.name);
-        /**
-         * E.g. 'Gtk'
-         */
-        const namespace = girModule.namespace;
-        /**
-         * E.g. '3.0'
-         */
-        const version = girModule.version;
-        let qualifiedName;
-        if (!className.includes('.')) {
-            qualifiedName = namespace + '.' + className;
-        }
-        else {
-            qualifiedName = className;
-            const split = className.split('.');
-            className = split[split.length - 1];
-        }
-        girClass._tsData = {
-            name: className,
-            qualifiedName,
-            parents: [],
-            namespace,
-            version,
-            isAbstract: this.isAbstractClass(girClass),
-            localNames: {},
-            constructPropNames: {},
-            inheritConstructPropInterfaceNames: [],
-            constructPropInterfaceName: `${namespace}.${className}.ConstructorProperties`,
-            fields: [],
-            properties: [],
-            conflictProperties: [],
-            constructProps: [],
-            propertySignalMethods: [],
-            methods: [],
-            conflictMethods: [],
-            virtualMethods: [],
-            constructors: [],
-            staticFunctions: [],
-            signals: [],
-            generics: [],
-            inherit: {},
-            implements: {},
-            girTypeName,
-            tsTypeName: this.girFactory.girTypeNameToTsTypeName(girTypeName, false),
-            doc: this.getTsDoc(girClass),
-        };
-        girClass._tsData.doc.tags.push(...this.getTsDocGirElementTags(girClass._tsData.tsTypeName, girClass._tsData.girTypeName));
-        girClass._tsData.parents = this.getClassParents(girClass);
-        if (girClass._tsData.parents.length) {
-            for (const parent of girClass._tsData.parents) {
-                girClass._tsData.inheritConstructPropInterfaceNames.push(`${parent.qualifiedParentName}.ConstructorProperties`);
-            }
-        }
-        girClass._tsData.isDerivedFromGObject = this.isDerivedFromGObject(girClass);
-        return girClass._tsData;
-    }
-    setClassTsData(girClass, girTypeName) {
-        if (!girClass?.$?.name)
-            return undefined;
-        if (girClass._tsData) {
-            return girClass._tsData;
-        }
-        girClass._tsData = this.setClassBaseTsData(girClass, girTypeName);
-        if (!girClass._tsData) {
-            return undefined;
-        }
-        // BASE
-        if (girClass._tsData.isDerivedFromGObject) {
-            girClass._tsData.constructProps.push(...this.getClassConstructPropsTsData(girClass, girClass._tsData.constructPropNames));
-        }
-        girClass._tsData.constructors.push(...this.getClassConstructorsTsData(girClass));
-        girClass._tsData.staticFunctions.push(...this.getClassStaticFunctionsTsData(girClass, girClass._tsData));
-        girClass._tsData.fields.push(...this.getClassFieldsTsData(girClass, girClass._tsData.localNames));
-        girClass._tsData.properties.push(...this.getClassPropertiesTsData(girClass, girClass._tsData.localNames));
-        girClass._tsData.methods.push(...this.getClassMethodsTsData(girClass, girClass._tsData.localNames));
-        girClass._tsData.virtualMethods.push(...this.getClassVirtualMethodsTsData(girClass));
-        girClass._tsData.signals.push(...this.getClassSignalsTsData(girClass));
-        girClass._tsData.properties.push(...this.getGObjectProperties(girClass));
-        // Copy fields, properties, methods, virtual methods and signals from inheritance tree
-        this.traverseInheritanceTree(girClass, girClass._tsData.girTypeName, (extendsCls, depth) => {
-            if (!girClass._tsData || !extendsCls._tsData || !extendsCls._fullSymName || !extendsCls._module) {
-                return;
-            }
-            if (girClass._fullSymName === extendsCls._fullSymName) {
-                return;
-            }
-            const key = extendsCls._module.packageName + '.' + extendsCls._fullSymName;
-            if (girClass._tsData.inherit[key])
-                return;
-            girClass._tsData.inherit[key] = {
-                depth,
-                class: extendsCls._tsData,
-            };
         });
-        // Copy properties, methods and signals from implemented interface
-        this.forEachInterface(girClass, girClass._tsData.girTypeName, (iface, depth) => {
-            if (!girClass._tsData || !iface._tsData || !iface._fullSymName || !iface._module) {
-                return;
-            }
-            if (girClass._fullSymName === iface._fullSymName) {
-                return;
-            }
-            const key = iface._module.packageName + '.' + iface._fullSymName;
-            if (girClass._tsData.implements[key])
-                return;
-            girClass._tsData.implements[key] = {
-                depth,
-                interface: iface._tsData,
-            };
-        });
-        this.inject.toClass(girClass);
-        girClass._tsData.propertySignalMethods.push(...this.getClassPropertySignalsMethods(girClass), ...this.getGeneralSignalsMethods(girClass._tsData));
-        if (this.config.fixConflicts) {
-            this.conflictResolver.repairClass(girClass);
-        }
-        return girClass._tsData;
-    }
-    isDerivedFromGObject(girClass) {
-        if (typeof girClass._tsData?.isDerivedFromGObject === 'boolean')
-            return girClass._tsData.isDerivedFromGObject;
-        let ret = false;
-        const onClassOrInterface = (cls) => {
-            if (cls._tsData?.isDerivedFromGObject === true || cls._fullSymName === 'GObject.Object') {
-                ret = true;
-            }
-        };
-        if (!girClass._tsData)
-            throw new Error(NO_TSDATA('isDerivedFromGObject'));
-        this.traverseInheritanceTree(girClass, girClass._tsData.tsTypeName, onClassOrInterface);
-        this.forEachInterface(girClass, girClass._tsData.tsTypeName, onClassOrInterface);
-        return ret;
-    }
-    getClassParent(parent) {
-        let parentPtr = undefined;
-        if (this.symTable.get(this.allDependencies, parent.qualifiedParentName)) {
-            parentPtr =
-                this.symTable.get(this.allDependencies, parent.qualifiedParentName) || undefined;
-        }
-        if (!parentPtr && parent.parentName == 'Object') {
-            parentPtr = this.symTable.getByHand('GObject-2.0.GObject.Object') || undefined;
-        }
-        return parentPtr;
-    }
-    traverseInheritanceTree(girClass, gitTypeName, callback, depth = 0, recursive = true) {
-        if (!girClass.$.name)
-            return;
-        if (!girClass._tsData)
-            girClass._tsData = this.setClassTsData(girClass, gitTypeName);
-        if (!girClass._tsData)
-            return;
-        callback(girClass, depth);
-        const parents = girClass._tsData.parents;
-        if (recursive && parents.length) {
-            ++depth;
-            if (depth >= MAX_CLASS_PARENT_DEPTH) {
-                this.log.error('[traverseInheritanceTree] Maximum recursion depth reached');
-                return;
-            }
-            for (const parent of parents) {
-                if (!parent.parentName || parent.type !== 'parent') {
-                    continue;
-                }
-                if (parent.cls) {
-                    if (parent.cls === girClass) {
-                        this.log.warn('[traverseInheritanceTree] A class cannot inherit itself');
-                        continue;
-                    }
-                    this.traverseInheritanceTree(parent.cls, parent.girTypeName, callback, depth, recursive);
-                }
-            }
-        }
-    }
-    forEachInterface(girIface, girTypeName, callback, recursive = true, depth = 0) {
-        if (!girIface.$.name)
-            return;
-        if (!girIface._tsData)
-            girIface._tsData = this.setClassTsData(girIface, girTypeName);
-        if (!girIface._tsData) {
-            throw new Error(NO_TSDATA('forEachInterface'));
-        }
-        const parents = girIface._tsData.parents;
-        if (parents.length) {
-            ++depth;
-            for (const parent of parents) {
-                if (!parent.parentName || parent.type === 'parent') {
-                    continue;
-                }
-                if (parent.cls) {
-                    callback(parent.cls, depth);
-                    // iface's prerequisite is also an interface, or it's
-                    // a class and we also want to recurse classes
-                    if (recursive)
-                        this.forEachInterface(parent.cls, parent.girTypeName, callback, recursive, depth);
-                }
-            }
-        }
-    }
-    /**
-     *
-     * @param girElement
-     * @param localNames Can be (constructor) properties, fields or methods
-     * @param type
-     */
-    checkOrSetLocalName(girElement, localNames, type) {
-        let isOverloadable = false;
-        if (!girElement._tsData) {
-            return null;
-        }
-        const name = girElement._tsData?.name;
-        if (!name) {
-            return null;
-        }
-        // Methods are overloadable by typescript
-        // TODO Add support for properties
-        if (type === 'method') {
-            isOverloadable = true;
-        }
-        // Only names of the same type are overloadable
-        if (localNames[name]?.type && localNames[name].type !== type) {
-            // In GIO there are some methods and properties with the same name
-            // E.g. on `WebKit2.WebView.isLoading` and `WebKit2.WebView.isLoading()`
-            // See Gjs doc https://gjs-docs.gnome.org/webkit240~4.0_api/webkit2.webview#property-is_loading
-            // TODO prefer functions over properties (Overwrite the properties with the functions if they have the same name)
-            return null;
-        }
-        // If name is found in localNames this variable was already defined
-        if (localNames?.[name]?.[type]?._tsData) {
-            // Ignore duplicates with the same type
-            // TODO should we use `this.functionSignaturesMatch` here?
-            if (type === 'method') {
-                const tsMethod1 = girElement._tsData;
-                const tsMethod2 = localNames[name][type]._tsData;
-                if (!tsMethod1 || !tsMethod2) {
-                    return null;
-                }
-                // if (ConflictResolver.functionConflict(tsMethod1, tsMethod2)) {
-                //     return null
-                // }
-            }
-            else {
-                // TODO better handling of property and field
-                if (isEqual(localNames[name][type]?._tsData, girElement._tsData)) {
-                    return null;
-                }
-            }
-            // Ignore if current method is not overloadable
-            if (!isOverloadable) {
-                return null;
-            }
-        }
-        localNames[name] = localNames[name] || {};
-        const localName = {
-            ...localNames[name],
-            [type]: girElement,
-            type,
-        };
-        localNames[name] = localName;
-        return { ...localName, added: true };
-    }
-    isGtypeStructFor(e, rec) {
-        const isFor = rec.$['glib:is-gtype-struct-for'];
-        return isFor && isFor == e.$.name;
-    }
-    /**
-     * E.g GObject.ObjectClass is a abstract class and required by UPowerGlib-1.0, UDisks-2.0 and others
-     * @param girClass
-     * @returns `true` if this is this a abstract class.
-     */
-    isAbstractClass(girClass) {
-        return girClass.$?.['glib:is-gtype-struct-for'] ? true : false;
-    }
-    /**
-     *
-     * @param girClass
-     * @returns
-     */
-    getOtherStaticFunctions(girClass) {
-        const girFunctions = [];
-        if (!girClass._tsData)
-            return girFunctions;
-        if (girClass.function?.length) {
-            for (const girFunction of girClass.function) {
-                girFunction._tsData = this.getFunctionTsData(girFunction, 'static-function', girClass._tsData, {
-                    isStatic: true,
-                    isArrowType: false,
-                    isGlobal: false,
-                    isVirtual: false,
-                    returnType: null,
-                    generics: [],
-                });
-                if (!girFunction._tsData?.name)
-                    continue;
-                if (girFunction._tsData.name.startsWith('new'))
-                    continue;
-                girFunctions.push(girFunction);
-            }
-        }
-        return girFunctions;
-    }
-    getStaticNewFunctions(girClass, parentClass) {
-        const girFunctions = [];
-        if (girClass.function?.length) {
-            for (const girFunction of girClass.function) {
-                girFunction._tsData = this.getConstructorFunctionTsData(parentClass, girFunction);
-                if (!girFunction._tsData?.name.startsWith('new'))
-                    continue;
-                girFunctions.push(girFunction);
-            }
-        }
-        return girFunctions;
-    }
-    /**
-     * Static methods, <constructor> and <function>
-     * @param girClass
-     * @param constructorTypeName Used to overwrite the constructor return type
-     * @param useReference This value should be `false` for inherited and implemented classes / interfaces.
-     * Otherwise other modules would overwrite the return value of the constructor methods
-     */
-    getClassStaticFunctionsTsData(girClass, parentClass) {
-        const girStaticFuncs = [];
-        girStaticFuncs.push(...this.getStaticNewFunctions(girClass, parentClass));
-        girStaticFuncs.push(...this.getOtherStaticFunctions(girClass));
-        girStaticFuncs.push(...this.getClassRecordMethods(girClass));
-        return girStaticFuncs;
-    }
-    setModuleTsData() {
-        if (this.ns.enumeration) {
-            for (const girEnum of this.ns.enumeration) {
-                if (girEnum.member) {
-                    for (const girEnumMember of girEnum.member) {
-                        girEnumMember._tsData = this.getEnumerationMemberTsData(girEnumMember, 'enum-member');
-                        if (!girEnumMember._tsData)
-                            continue;
+        // Get the requested classes
+        if (ns.class) {
+            ns.class
+                ?.filter(isIntrospectable)
+                .map((klass) => IntrospectedClass.fromXML(klass, building, options))
+                .filter(importConflicts)
+                .forEach((c) => building.members.set(c.name, c));
+        }
+        if (ns.record) {
+            ns.record
+                ?.filter(isIntrospectable)
+                .map((record) => IntrospectedRecord.fromXML(record, building, options))
+                .filter(importConflicts)
+                .forEach((c) => building.members.set(c.name, c));
+        }
+        if (ns.union) {
+            ns.union
+                ?.filter(isIntrospectable)
+                .map((union) => IntrospectedRecord.fromXML(union, building, options))
+                .filter(importConflicts)
+                .forEach((c) => building.members.set(c.name, c));
+        }
+        if (ns.interface) {
+            ns.interface
+                ?.map((inter) => IntrospectedInterface.fromXML(inter, building, options))
+                .filter(importConflicts)
+                .forEach((c) => building.members.set(c.name, c));
+        }
+        if (ns.alias) {
+            ns.alias
+                ?.filter(isIntrospectable)
+                // Avoid attempting to alias non-introspectable symbols.
+                .map((b) => {
+                b.type = b.type
+                    ?.filter((t) => !!(t && t.$.name))
+                    .map((t) => {
+                    if (t.$.name &&
+                        !building.hasSymbol(t.$.name) &&
+                        !isPrimitiveType(t.$.name) &&
+                        !t.$.name.includes('.')) {
+                        return { $: { name: 'unknown', 'c:type': 'unknown' } };
                     }
-                }
-                girEnum._tsData = this.getEnumerationTsData(girEnum, 'enum');
-                this.fixEnumerationDuplicateIdentifier(girEnum);
-                if (!girEnum._tsData)
-                    continue;
-            }
-        }
-        if (this.ns.bitfield)
-            for (const girBitfield of this.ns.bitfield) {
-                if (girBitfield.member)
-                    for (const girEnumMember of girBitfield.member) {
-                        girEnumMember._tsData = this.getEnumerationMemberTsData(girEnumMember, 'bitfield-member');
-                    }
-                girBitfield._tsData = this.getEnumerationTsData(girBitfield, 'bitfield');
-                if (!girBitfield._tsData)
-                    continue;
-                this.fixEnumerationDuplicateIdentifier(girBitfield);
-            }
-        if (this.ns.constant)
-            for (const girConst of this.ns.constant) {
-                girConst._tsData = this.getConstantTsData(girConst, null);
-                if (!girConst._tsData)
-                    continue;
-            }
-        if (this.ns.function) {
-            for (const girFunc of this.ns.function) {
-                girFunc._tsData = this.getFunctionTsData(girFunc, 'function', null, {
-                    isStatic: false,
-                    isArrowType: false,
-                    isGlobal: true,
-                    isVirtual: false,
-                    returnType: null,
-                    generics: [],
+                    return t;
                 });
-                if (!girFunc._tsData)
-                    continue;
-            }
-            this.overloadPromisifiedFunctions(this.ns.function);
-        }
-        if (this.ns.callback)
-            for (const girCallback of this.ns.callback) {
-                girCallback._tsData = this.setCallbackTsData(girCallback, null);
-            }
-        if (this.ns.interface)
-            for (const girIface of this.ns.interface) {
-                girIface._tsData = this.setClassTsData(girIface, 'interface');
-            }
-        if (this.ns.class)
-            for (const girClass of this.ns.class) {
-                girClass._tsData = this.setClassTsData(girClass, 'class');
-                if (!girClass._tsData)
-                    continue;
-            }
-        if (this.ns.record)
-            for (const girRecord of this.ns.record) {
-                girRecord._tsData = this.setClassTsData(girRecord, 'record');
-                if (!girRecord._tsData)
-                    continue;
-            }
-        if (this.ns.union)
-            for (const girUnion of this.ns.union) {
-                girUnion._tsData = this.setClassTsData(girUnion, 'union');
-                if (!girUnion._tsData)
-                    continue;
-            }
-        if (this.ns.alias) {
-            for (const girAlias of this.ns.alias) {
-                // GType is not a number in GJS
-                if (this.packageName !== 'GObject-2.0' || girAlias.$.name !== 'Type')
-                    girAlias._tsData = this.getAliasTsData(girAlias, null);
-                if (!girAlias._tsData)
-                    continue;
-            }
-        }
-    }
-    /**
-     * TODO: find better name for this method
-     * @param fullTypeName
-     * @returns
-     */
-    fullTypeLookupWithNamespace(fullTypeName) {
-        let resValue = '';
-        let namespace = '';
-        // Check overwrites first
-        if (!resValue && fullTypeName && FULL_TYPE_MAP(this.config.environment, fullTypeName)) {
-            resValue = FULL_TYPE_MAP(this.config.environment, fullTypeName) || '';
-        }
-        // Only use the fullTypeName as the type if it is found in the symTable
-        if (!resValue && this.symTable.get(this.allDependencies, fullTypeName)) {
-            if (fullTypeName.startsWith(this.namespace + '.')) {
-                resValue = removeNamespace(fullTypeName, this.namespace);
-                resValue = this.transformation.transformTypeName(resValue);
-                // TODO: check if resValue is a class, enum or interface before transformClassName
-                resValue = this.transformation.transformClassName(resValue);
-                namespace = this.namespace;
-                resValue = namespace + '.' + resValue;
-            }
-            else {
-                const resValues = fullTypeName.split('.');
-                resValues.map((name) => this.transformation.transformTypeName(name));
-                // TODO: check if resValues[resValues.length - 1] is a class, enum, interface before transformClassName
-                resValues[resValues.length - 1] = this.transformation.transformClassName(resValues[resValues.length - 1]);
-                resValue = resValues.join('.');
-                namespace = resValues[0];
-            }
-        }
-        return {
-            value: resValue,
-            namespace,
-        };
-    }
-    loadInheritance(inheritanceTable) {
-        // Class hierarchy
-        for (const girClass of this.ns.class ? this.ns.class : []) {
-            let parent = null;
-            if (girClass.$ && girClass.$.parent)
-                parent = girClass.$.parent;
-            if (!parent)
-                continue;
-            if (!girClass._fullSymName)
-                continue;
-            if (!parent.includes('.')) {
-                parent = addNamespace(parent, this.namespace);
-            }
-            const className = girClass._fullSymName;
-            const arr = inheritanceTable[className] || [];
-            arr.push(parent);
-            inheritanceTable[className] = arr;
-        }
-        // Class interface implementations
-        for (const girClass of this.ns.class ? this.ns.class : []) {
-            if (!girClass._fullSymName)
-                continue;
-            const names = [];
-            if (girClass.implements) {
-                for (const girImplements of girClass.implements) {
-                    if (girImplements.$.name) {
-                        let name = girImplements.$.name;
-                        if (!name.includes('.')) {
-                            name = girClass._fullSymName.substring(0, girClass._fullSymName.indexOf('.') + 1) + name;
-                        }
-                        names.push(name);
-                    }
-                }
-            }
-            if (names.length > 0) {
-                const className = girClass._fullSymName;
-                const arr = inheritanceTable[className] || [];
-                inheritanceTable[className] = arr.concat(names);
-            }
-        }
-    }
-    loadTypes() {
-        if (this.ns.bitfield)
-            this.annotateAndRegisterGirElement(this.ns.bitfield);
-        if (this.ns.callback)
-            this.annotateAndRegisterGirElement(this.ns.callback);
-        if (this.ns.class)
-            this.annotateAndRegisterGirElement(this.ns.class);
-        if (this.ns.constant)
-            this.annotateAndRegisterGirElement(this.ns.constant);
-        if (this.ns.enumeration)
-            this.annotateAndRegisterGirElement(this.ns.enumeration);
-        if (this.ns.function)
-            this.annotateAndRegisterGirElement(this.ns.function);
-        if (this.ns.interface)
-            this.annotateAndRegisterGirElement(this.ns.interface);
-        if (this.ns.record)
-            this.annotateAndRegisterGirElement(this.ns.record);
-        if (this.ns.union)
-            this.annotateAndRegisterGirElement(this.ns.union);
-        if (this.ns.alias)
-            this.annotateAndRegisterGirElement(this.ns.alias);
-        if (this.ns.callback)
-            for (const girCallback of this.ns.callback)
-                this.annotateFunctionArguments(girCallback);
-        for (const girClass of this.ns.class || []) {
-            this.annotateClass(girClass, 'class');
-        }
-        for (const girClass of this.ns.record || []) {
-            this.annotateClass(girClass, 'record');
-        }
-        for (const girClass of this.ns.interface || []) {
-            this.annotateClass(girClass, 'interface');
-        }
-        if (this.ns.function)
-            this.annotateFunctions(this.ns.function);
-        if (this.ns.callback)
-            this.annotateFunctions(this.ns.callback);
-        if (this.ns.constant)
-            this.annotateVariables(this.ns.constant);
-    }
-    /**
-     * Before processing the typescript data, each module should be initialized first.
-     * This is done in the `GenerationHandler`.
-     */
-    init(inheritanceTable) {
-        this.loadTypes();
-        this.loadInheritance(inheritanceTable);
+                return b;
+            })
+                .map((alias) => IntrospectedAlias.fromXML(alias, building, options))
+                .filter((alias) => alias != null)
+                .forEach((c) => building.members.set(c.name, c));
+        }
+        building.namespace = building.ns.name;
+        building.version = building.ns.version;
+        building.packageName = `${building.namespace}-${building.version}`;
+        building.libraryVersion = new LibraryVersion(ns.constant, building.version);
+        building.transformation = new Transformation(config);
+        building.log = new Logger(config.verbose, building.packageName || 'GirModule');
+        building.importNamespace = building.transformation.transformModuleNamespaceName(building.packageName);
+        building.importName = building.transformation.transformImportName(building.packageName);
+        building.symTable = new SymTable(building.config, building.packageName, building.namespace);
+        return building;
     }
     /**
      * Start processing the typescript data
@@ -2287,7 +516,59 @@ export class GirModule {
                 this.libraryVersion = glibModule.libraryVersion;
             }
         }
-        this.setModuleTsData();
     }
 }
+export const isIntrospectable = (e) => !e || !e.$ || !e.$.introspectable || e.$.introspectable === '1';
+export const isDeprecated = (e) => e && e.$ && e.$.deprecated === '1';
+export const deprecatedVersion = (e) => e?.$?.['deprecated-version'];
+export const introducedVersion = (e) => e?.$?.version;
+export function promisifyNamespaceFunctions(namespace) {
+    return namespace.members.forEach((node) => {
+        if (!(node instanceof IntrospectedFunction))
+            return;
+        if (node.parameters.length < 1)
+            return;
+        const last_param = node.parameters[node.parameters.length - 1];
+        if (!last_param)
+            return;
+        const last_param_unwrapped = last_param.type.unwrap();
+        if (!(last_param_unwrapped instanceof ClosureType))
+            return;
+        const internal = last_param_unwrapped.type;
+        if (internal instanceof TypeIdentifier && internal.is('Gio', 'AsyncReadyCallback')) {
+            const async_res = [
+                ...Array.from(namespace.members.values()).filter((m) => m instanceof IntrospectedFunction),
+            ].find((m) => m.name === `${node.name.replace(/_async$/, '')}_finish` || m.name === `${node.name}_finish`);
+            if (async_res) {
+                const async_parameters = node.parameters.slice(0, -1).map((p) => p.copy());
+                const sync_parameters = node.parameters.map((p) => p.copy({ isOptional: false }));
+                const output_parameters = async_res.output_parameters;
+                let async_return = new PromiseType(async_res.return());
+                if (output_parameters.length > 0) {
+                    const raw_return = async_res.return();
+                    if (raw_return.equals(VoidType) || raw_return.equals(BooleanType)) {
+                        const [output_type, ...output_types] = output_parameters.map((op) => op.type);
+                        async_return = new PromiseType(new TupleType(output_type, ...output_types));
+                    }
+                    else {
+                        const [...output_types] = output_parameters.map((op) => op.type);
+                        async_return = new PromiseType(new TupleType(raw_return, ...output_types));
+                    }
+                }
+                namespace.members.set(node.name, [
+                    node.copy({
+                        parameters: async_parameters,
+                        return_type: async_return,
+                    }),
+                    node.copy({
+                        parameters: sync_parameters,
+                    }),
+                    node.copy({
+                        return_type: new BinaryType(async_return, node.return()),
+                    }),
+                ]);
+            }
+        }
+    });
+}
 //# sourceMappingURL=gir-module.js.map