@ts-for-gir/lib 3.0.0-beta.11

package/lib/gir-module.js

@@ -0,0 +1,2181 @@
+// TODO move this class into a web-worker? https://www.npmjs.com/package/web-worker
+import { Transformation, C_TYPE_MAP, FULL_TYPE_MAP, POD_TYPE_MAP, POD_TYPE_MAP_ARRAY, IGNORE_GIR_TYPE_TS_DOC_TYPES, } from './transformation.js';
+import { STATIC_NAME_ALREADY_EXISTS, MAX_CLASS_PARENT_DEPTH } from './constants.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 } from './utils.js';
+import { SymTable } from './symtable.js';
+export class GirModule {
+    config;
+    /**
+     * Array of all gir modules
+     */
+    static allGirModules = [];
+    /**
+     * E.g. 'Gtk'
+     */
+    namespace;
+    /**
+     * E.g. '3.0'
+     */
+    version = '0.0';
+    /**
+     * E.g. 'Gtk-3.0'
+     */
+    packageName;
+    /**
+     * E.g. 'Gtk30'
+     * Is used in the generated index.d.ts, for example: `import * as Gtk30 from "./Gtk-3.0.js";`
+     */
+    importName;
+    dependencies = [];
+    _transitiveDependencies = [];
+    set transitiveDependencies(deps) {
+        this._transitiveDependencies = this.checkTransitiveDependencies(deps);
+    }
+    get transitiveDependencies() {
+        return this._transitiveDependencies;
+    }
+    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) {
+        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.transformation = new Transformation(this.packageName, 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.importName = this.transformation.transformModuleNamespaceName(this.packageName);
+        this.symTable = new SymTable(this.config, this.packageName, this.namespace);
+    }
+    checkTransitiveDependencies(transitiveDependencies) {
+        // Always pull in GObject-2.0, as we may need it for e.g. GObject-2.0.type
+        if (this.packageName !== 'GObject-2.0') {
+            if (!find(transitiveDependencies, (x) => x.packageName === 'GObject-2.0')) {
+                transitiveDependencies.push(this.dependencyManager.get('GObject', '2.0'));
+            }
+        }
+        // Add missing dependencies
+        if (this.packageName === 'UnityExtras-7.0') {
+            if (!find(transitiveDependencies, (x) => x.packageName === 'Unity-7.0')) {
+                transitiveDependencies.push(this.dependencyManager.get('Unity', '7.0'));
+            }
+        }
+        if (this.packageName === 'UnityExtras-6.0') {
+            if (!find(transitiveDependencies, (x) => x.packageName === 'Unity-6.0')) {
+                transitiveDependencies.push(this.dependencyManager.get('Unity', '6.0'));
+            }
+        }
+        if (this.packageName === 'GTop-2.0') {
+            if (!find(transitiveDependencies, (x) => x.packageName === 'GLib-2.0')) {
+                transitiveDependencies.push(this.dependencyManager.get('GLib', '2.0'));
+            }
+        }
+        return transitiveDependencies;
+    }
+    getTsDoc(girDoc) {
+        const tsDoc = {
+            text: '',
+            tags: [],
+        };
+        if (girDoc.doc?.[0]?._) {
+            let text = girDoc.doc?.[0]?._ || '';
+            text = this.transformation.transformGirDocText(text);
+            tsDoc.text = text;
+        }
+        return tsDoc;
+    }
+    getTsDocGirElementTags(tsTypeName, girTypeName) {
+        const tags = [];
+        if (!girTypeName || IGNORE_GIR_TYPE_TS_DOC_TYPES.includes(girTypeName)) {
+            return tags;
+        }
+        tags.push({
+            tagName: girTypeName,
+            paramName: '',
+            text: '',
+        });
+        return tags;
+    }
+    getTsDocReturnTags(girElement) {
+        const girReturnValue = girElement?.['return-value']?.[0];
+        if (!girReturnValue || !girReturnValue.doc?.[0]?._) {
+            return [];
+        }
+        const returnTag = {
+            tagName: 'returns',
+            paramName: '',
+            text: this.transformation.transformGirDocTagText(girReturnValue.doc[0]._),
+        };
+        return [returnTag];
+    }
+    getTsDocInParamTags(inParams) {
+        const tags = [];
+        if (!inParams?.length) {
+            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) {
+                tags.push({
+                    paramName: inParam._tsData.name,
+                    tagName: 'param',
+                    text: inParam._tsData.doc.text
+                        ? this.transformation.transformGirDocTagText(inParam._tsData.doc.text)
+                        : '',
+                });
+            }
+        }
+        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}`;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    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}`;
+            }
+        }
+    }
+    /**
+     * 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);
+            }
+        }
+    }
+    /**
+     * 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 (isArray && arrayType?.$?.name && POD_TYPE_MAP_ARRAY[arrayType.$.name]) {
+            isArray = false;
+            overrideTypeName = POD_TYPE_MAP_ARRAY[arrayType.$.name];
+        }
+        return {
+            arrCType,
+            arrayType,
+            isArray,
+            overrideTypeName,
+        };
+    }
+    /**
+     * Get the typescript type of a GirElement like a `GirPropertyElement` or `GirCallableReturn`
+     * @param girVar
+     */
+    getTsType(girVar, tsClass, 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) || defaults.nullable || false;
+        const optional = this.typeIsOptional(girVar) || 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;
+            }
+        }
+        if (!typeName && type?.$?.name && POD_TYPE_MAP[type.$.name]) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            typeName = POD_TYPE_MAP[type.$.name];
+        }
+        if (cType) {
+            if (!typeName && C_TYPE_MAP(cType)) {
+                typeName = C_TYPE_MAP(cType) || '';
+            }
+            if (!typeName && POD_TYPE_MAP[cType]) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                typeName = POD_TYPE_MAP[cType];
+            }
+        }
+        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;
+    }
+    /**
+     *
+     * @param girFunc
+     * @returns
+     */
+    getReturnType(girFunc, tsClass, generics = []) {
+        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, { 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]);
+        }
+    }
+    /**
+     * Checks if the parameter is nullable (which results in ` | null`).
+     *
+     * @param girVar girVar to test
+     */
+    typeIsNullable(girVar) {
+        const a = girVar.$;
+        if (!a)
+            return false;
+        // Ignore depreciated `allow-none` if one of the new implementation `optional` or `nullable` is set
+        if (girBool(a.optional) || girBool(a.nullable)) {
+            return girBool(a.nullable);
+        }
+        else {
+            return girBool(a.nullable) || girBool(a['allow-none']);
+        }
+    }
+    /**
+     * Checks if the parameter is optional (which results in `foo?: bar`).
+     * @param girVar girVar to test
+     */
+    typeIsOptional(girVar) {
+        const a = girVar.$;
+        if (!a)
+            return false;
+        // Ignore depreciated `allow-none` if one of the new implementation `optional` or `nullable` is set
+        if (girBool(a.optional) || girBool(a.nullable)) {
+            return girBool(a.optional);
+        }
+        else {
+            return girBool(a.optional) || girBool(a['allow-none']);
+        }
+    }
+    setParameterTsData(girParam, girParams, paramNames, skip, parent) {
+        // 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);
+        // 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 !== 'out');
+            if (following.some((p) => !this.typeIsOptional(p))) {
+                tsType.optional = false;
+            }
+        }
+        const tsParam = {
+            name: paramName,
+            type: [tsType],
+            isRest: false,
+            girTypeName: 'callable-param',
+            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);
+                    }
+                }
+                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 === 'out' || optDirection === 'inout') {
+                            outParams.push(param);
+                            if (optDirection === 'out')
+                                continue;
+                        }
+                        inParams.push(param);
+                    }
+                }
+            }
+        }
+        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;
+        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, { 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;
+    }
+    /**
+     *
+     * @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;
+        }
+        if (optional === undefined)
+            optional = this.typeIsOptional(girProp);
+        if (nullable === undefined)
+            nullable = this.typeIsNullable(girProp);
+        const readonly = !girBool(girProp.$.writable) || (!construct && girBool(girProp.$['construct-only']));
+        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}`);
+        }
+        if (!tsData?.name) {
+            return undefined;
+        }
+        tsData = {
+            ...tsData,
+            readonly,
+        };
+        return tsData;
+    }
+    /**
+     *
+     * @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;
+        }
+        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;
+        }
+        // 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,
+            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;
+    }
+    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;
+            }
+        }
+        // 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 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);
+        }
+    }
+    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);
+        }
+        return girCallback._tsData;
+    }
+    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';
+        }
+        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;
+    }
+    /**
+     * 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'));
+        }
+        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);
+    }
+    /**
+     * 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'));
+        }
+        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;
+    }
+    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;
+    }
+    fixEnumerationDuplicateIdentifier(girEnum) {
+        if (!girElementIsIntrospectable(girEnum))
+            return girEnum;
+        if (!girEnum._tsData) {
+            throw new Error(NO_TSDATA('fixEnumerationDuplicateIdentifier'));
+        }
+        if (!girEnum.member?.length) {
+            return girEnum;
+        }
+        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;
+    }
+    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;
+        }
+        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),
+        };
+        tsData.doc.tags.push(...this.getTsDocGirElementTags(tsData.tsTypeName, tsData.girTypeName));
+        return tsData;
+    }
+    getAliasTsData(girAlias, tsClass) {
+        if (!girElementIsIntrospectable(girAlias))
+            return undefined;
+        if (girAlias._tsData) {
+            // this.log.warn('[getEnumerationMemberTsData] _tsData already set!')
+            return girAlias._tsData;
+        }
+        const { type: typeName } = this.getTsType(girAlias, tsClass);
+        const name = girAlias.$.name;
+        const tsData = {
+            name,
+            type: typeName,
+            girTypeName: 'alias',
+            tsTypeName: this.girFactory.girTypeNameToTsTypeName('alias', false),
+        };
+        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;
+    }
+    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);
+        }
+        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;
+    }
+    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);
+                }
+            }
+        }
+        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);
+                    }
+                }
+                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: [],
+            });
+            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;
+                    }
+                }
+                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: [],
+                });
+                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);
+    }
+    /**
+     * Start processing the typescript data
+     */
+    start() {
+        this.setModuleTsData();
+    }
+}
+//# sourceMappingURL=gir-module.js.map