@gtkx/gir 0.10.5 → 0.11.1

package/dist/types.js

@@ -1,1123 +1,781 @@
 /**
- * GIR type definitions and utilities.
+ * Normalized GIR types with helper methods.
  *
- * Provides TypeScript representations of GObject Introspection data
- * and utilities for type resolution and mapping.
- *
- * @packageDocumentation
+ * All type references use fully qualified names (Namespace.TypeName)
+ * except for intrinsic types which remain unqualified.
  */
-import { normalizeClassName } from "./class-names.js";
-import { toCamelCase, toPascalCase } from "./naming.js";
-export { toCamelCase, toPascalCase };
+import { isIntrinsicType, isNumericType, isStringType, isVoidType } from "./intrinsics.js";
 /**
- * Builds a lookup map from class name to class definition.
- *
- * @param classes - Array of parsed GIR classes
- * @returns Map keyed by class name for O(1) lookup
+ * Creates a QualifiedName from namespace and type name.
  */
-export const buildClassMap = (classes) => {
-    const classMap = new Map();
-    for (const cls of classes) {
-        classMap.set(cls.name, cls);
-    }
-    return classMap;
+export const qualifiedName = (namespace, name) => {
+    return `${namespace}.${name}`;
 };
 /**
- * Registers all enumerations and bitfields from a namespace into a type mapper.
- *
- * @param typeMapper - The type mapper to register enums with
- * @param namespace - The parsed GIR namespace containing enums
+ * Parses a QualifiedName into its parts.
  */
-export const registerEnumsFromNamespace = (typeMapper, namespace) => {
-    for (const enumeration of namespace.enumerations) {
-        typeMapper.registerEnum(enumeration.name, toPascalCase(enumeration.name));
-    }
-    for (const bitfield of namespace.bitfields) {
-        typeMapper.registerFlags(bitfield.name, toPascalCase(bitfield.name));
-    }
+export const parseQualifiedName = (qn) => {
+    const dot = qn.indexOf(".");
+    return {
+        namespace: qn.slice(0, dot),
+        name: qn.slice(dot + 1),
+    };
 };
 /**
- * Registry for resolving types across multiple GIR namespaces.
- *
- * Enables cross-namespace type resolution by maintaining a map of
- * all known types from all loaded namespaces.
- *
- * @example
- * ```tsx
- * const registry = TypeRegistry.fromNamespaces([gtkNamespace, gioNamespace]);
- * const buttonType = registry.resolve("Gtk.Button");
- * ```
+ * Normalized namespace containing all resolved types.
  */
-export class TypeRegistry {
-    types = new Map();
-    /**
-     * Registers a native class type.
-     *
-     * @param namespace - The GIR namespace (e.g., "Gtk")
-     * @param name - The class name (e.g., "Button")
-     */
-    registerNativeClass(namespace, name) {
-        const transformedName = normalizeClassName(name, namespace);
-        this.types.set(`${namespace}.${name}`, {
-            kind: "class",
-            name,
-            namespace,
-            transformedName,
-        });
-    }
-    /**
-     * Registers an interface type.
-     *
-     * @param namespace - The GIR namespace
-     * @param name - The interface name
-     */
-    registerInterface(namespace, name) {
-        const transformedName = normalizeClassName(name, namespace);
-        this.types.set(`${namespace}.${name}`, {
-            kind: "interface",
-            name,
-            namespace,
-            transformedName,
-        });
-    }
-    /**
-     * Registers an enumeration type.
-     *
-     * @param namespace - The GIR namespace
-     * @param name - The enum name
-     */
-    registerEnum(namespace, name) {
-        const transformedName = toPascalCase(name);
-        this.types.set(`${namespace}.${name}`, {
-            kind: "enum",
-            name,
-            namespace,
-            transformedName,
-        });
-    }
-    /**
-     * Registers a flags (bitfield) type.
-     *
-     * @param namespace - The GIR namespace
-     * @param name - The flags name
-     */
-    registerFlags(namespace, name) {
-        const transformedName = toPascalCase(name);
-        this.types.set(`${namespace}.${name}`, {
-            kind: "flags",
-            name,
-            namespace,
-            transformedName,
-        });
-    }
-    /**
-     * Registers a record (boxed) type.
-     *
-     * @param namespace - The GIR namespace
-     * @param name - The record name
-     * @param glibTypeName - Optional GLib type name for runtime type info
-     * @param sharedLibrary - Optional shared library containing the type
-     * @param glibGetType - Optional get_type function name
-     * @param isPlainStruct - If true, this is a plain C struct without GType
-     * @param structSize - Size in bytes for plain structs
-     * @param structFields - Field definitions for plain structs
-     */
-    registerRecord(namespace, name, glibTypeName, sharedLibrary, glibGetType, isPlainStruct, structSize, structFields) {
-        const transformedName = normalizeClassName(name, namespace);
-        this.types.set(`${namespace}.${name}`, {
-            kind: "record",
-            name,
-            namespace,
-            transformedName,
-            glibTypeName,
-            sharedLibrary,
-            glibGetType,
-            isPlainStruct,
-            structSize,
-            structFields,
-        });
-    }
-    /**
-     * Registers a callback type.
-     *
-     * @param namespace - The GIR namespace
-     * @param name - The callback name
-     */
-    registerCallback(namespace, name) {
-        const transformedName = toPascalCase(name);
-        this.types.set(`${namespace}.${name}`, {
-            kind: "callback",
-            name,
-            namespace,
-            transformedName,
-        });
-    }
-    /**
-     * Resolves a fully qualified type name.
-     *
-     * @param qualifiedName - Type name in "Namespace.TypeName" format
-     * @returns The registered type, or undefined if not found
-     */
-    resolve(qualifiedName) {
-        return this.types.get(qualifiedName);
-    }
-    /**
-     * Resolves a type name within a namespace context.
-     *
-     * First checks the current namespace, then falls back to
-     * searching all registered types.
-     *
-     * @param name - Type name (may be unqualified)
-     * @param currentNamespace - The namespace to search first
-     * @returns The registered type, or undefined if not found
-     */
-    resolveInNamespace(name, currentNamespace) {
-        if (name.includes(".")) {
-            return this.resolve(name);
-        }
-        const inCurrent = this.resolve(`${currentNamespace}.${name}`);
-        if (inCurrent) {
-            return inCurrent;
+export class GirNamespace {
+    name;
+    version;
+    sharedLibrary;
+    cPrefix;
+    classes;
+    interfaces;
+    records;
+    enumerations;
+    bitfields;
+    callbacks;
+    functions;
+    constants;
+    doc;
+    constructor(data) {
+        this.name = data.name;
+        this.version = data.version;
+        this.sharedLibrary = data.sharedLibrary;
+        this.cPrefix = data.cPrefix;
+        this.classes = data.classes;
+        this.interfaces = data.interfaces;
+        this.records = data.records;
+        this.enumerations = data.enumerations;
+        this.bitfields = data.bitfields;
+        this.callbacks = data.callbacks;
+        this.functions = data.functions;
+        this.constants = data.constants;
+        this.doc = data.doc;
+    }
+}
+/**
+ * Normalized class with helper methods.
+ */
+export class GirClass {
+    name;
+    qualifiedName;
+    cType;
+    parent;
+    abstract;
+    glibTypeName;
+    glibGetType;
+    cSymbolPrefix;
+    implements;
+    methods;
+    constructors;
+    staticFunctions;
+    properties;
+    signals;
+    doc;
+    /** @internal */
+    _repo;
+    constructor(data) {
+        this.name = data.name;
+        this.qualifiedName = data.qualifiedName;
+        this.cType = data.cType;
+        this.parent = data.parent;
+        this.abstract = data.abstract;
+        this.glibTypeName = data.glibTypeName;
+        this.glibGetType = data.glibGetType;
+        this.cSymbolPrefix = data.cSymbolPrefix;
+        this.implements = data.implements;
+        this.methods = data.methods;
+        this.constructors = data.constructors;
+        this.staticFunctions = data.staticFunctions;
+        this.properties = data.properties;
+        this.signals = data.signals;
+        this.doc = data.doc;
+    }
+    /** @internal */
+    _setRepository(repo) {
+        this._repo = repo;
+    }
+    /** Checks if this class is a subclass of another (direct or transitive). */
+    isSubclassOf(qualifiedName) {
+        if (this.qualifiedName === qualifiedName)
+            return true;
+        if (!this.parent || !this._repo)
+            return false;
+        if (this.parent === qualifiedName)
+            return true;
+        const parentClass = this._repo.resolveClass(this.parent);
+        return parentClass?.isSubclassOf(qualifiedName) ?? false;
+    }
+    /** Gets the full inheritance chain from this class to the root. */
+    getInheritanceChain() {
+        const chain = [this.qualifiedName];
+        let current = this;
+        while (current?.parent && this._repo) {
+            chain.push(current.parent);
+            current = this._repo.resolveClass(current.parent);
         }
-        for (const type of this.types.values()) {
-            if (type.name === name || type.transformedName === name) {
-                return type;
+        return chain;
+    }
+    /** Gets the parent class object, or null if this is a root class. */
+    getParent() {
+        return this.parent && this._repo ? this._repo.resolveClass(this.parent) : null;
+    }
+    /** Checks if this class directly or transitively implements an interface. */
+    implementsInterface(qualifiedName) {
+        if (this.implements.includes(qualifiedName))
+            return true;
+        const parent = this.getParent();
+        return parent?.implementsInterface(qualifiedName) ?? false;
+    }
+    /** Gets all implemented interfaces including inherited ones. */
+    getAllImplementedInterfaces() {
+        const interfaces = new Set(this.implements);
+        let current = this.getParent();
+        while (current) {
+            for (const iface of current.implements) {
+                interfaces.add(iface);
             }
+            current = current.getParent();
+        }
+        return [...interfaces];
+    }
+    /** Finds a method defined on this class by name. */
+    getMethod(name) {
+        return this.methods.find((m) => m.name === name) ?? null;
+    }
+    /** Finds a property defined on this class by name. */
+    getProperty(name) {
+        return this.properties.find((p) => p.name === name) ?? null;
+    }
+    /** Finds a signal defined on this class by name. */
+    getSignal(name) {
+        return this.signals.find((s) => s.name === name) ?? null;
+    }
+    /** Finds a constructor by name. */
+    getConstructor(name) {
+        return this.constructors.find((c) => c.name === name) ?? null;
+    }
+    /** Gets all methods including inherited ones. */
+    getAllMethods() {
+        const methods = [...this.methods];
+        let current = this.getParent();
+        while (current) {
+            methods.push(...current.methods);
+            current = current.getParent();
         }
+        return methods;
+    }
+    /** Gets all properties including inherited ones. */
+    getAllProperties() {
+        const properties = [...this.properties];
+        let current = this.getParent();
+        while (current) {
+            properties.push(...current.properties);
+            current = current.getParent();
+        }
+        return properties;
+    }
+    /** Gets all signals including inherited ones. */
+    getAllSignals() {
+        const signals = [...this.signals];
+        let current = this.getParent();
+        while (current) {
+            signals.push(...current.signals);
+            current = current.getParent();
+        }
+        return signals;
+    }
+    /** Finds a method by name, searching up the inheritance chain. */
+    findMethod(name) {
+        const own = this.getMethod(name);
+        if (own)
+            return own;
+        return this.getParent()?.findMethod(name) ?? null;
+    }
+    /** Finds a property by name, searching up the inheritance chain. */
+    findProperty(name) {
+        const own = this.getProperty(name);
+        if (own)
+            return own;
+        return this.getParent()?.findProperty(name) ?? null;
+    }
+    /** Finds a signal by name, searching up the inheritance chain. */
+    findSignal(name) {
+        const own = this.getSignal(name);
+        if (own)
+            return own;
+        return this.getParent()?.findSignal(name) ?? null;
+    }
+    /** True if this is an abstract class. */
+    isAbstract() {
+        return this.abstract;
+    }
+    /** True if this has a GType (most GObject classes do). */
+    hasGType() {
+        return this.glibTypeName !== undefined;
+    }
+    /** Gets direct subclasses of this class. */
+    getDirectSubclasses() {
+        if (!this._repo)
+            return [];
+        return this._repo.findClasses((cls) => cls.parent === this.qualifiedName);
     }
-    /**
-     * Creates a type registry from multiple parsed namespaces.
-     *
-     * @param namespaces - Array of parsed GIR namespaces
-     * @returns A populated type registry
-     *
-     * @example
-     * ```tsx
-     * const parser = new GirParser();
-     * const gtk = parser.parse(gtkGir);
-     * const gio = parser.parse(gioGir);
-     * const registry = TypeRegistry.fromNamespaces([gtk, gio]);
-     * ```
-     */
-    static fromNamespaces(namespaces) {
-        const registry = new TypeRegistry();
-        for (const ns of namespaces) {
-            for (const cls of ns.classes) {
-                registry.registerNativeClass(ns.name, cls.name);
-            }
-            for (const iface of ns.interfaces) {
-                registry.registerInterface(ns.name, iface.name);
-            }
-            for (const enumeration of ns.enumerations) {
-                registry.registerEnum(ns.name, enumeration.name);
-            }
-            for (const bitfield of ns.bitfields) {
-                registry.registerFlags(ns.name, bitfield.name);
-            }
-            for (const record of ns.records) {
-                if (record.disguised)
-                    continue;
-                if (record.glibTypeName) {
-                    registry.registerRecord(ns.name, record.name, record.glibTypeName, ns.sharedLibrary, record.glibGetType);
-                }
-                else if (record.fields.length > 0 && !record.opaque && hasOnlyPrimitiveFields(record.fields)) {
-                    const { size, fields } = calculateStructLayout(record.fields);
-                    registry.registerRecord(ns.name, record.name, undefined, ns.sharedLibrary, undefined, true, size, fields);
+}
+/**
+ * Normalized interface with helper methods.
+ */
+export class GirInterface {
+    name;
+    qualifiedName;
+    cType;
+    glibTypeName;
+    prerequisites;
+    methods;
+    properties;
+    signals;
+    doc;
+    /** @internal */
+    _repo;
+    constructor(data) {
+        this.name = data.name;
+        this.qualifiedName = data.qualifiedName;
+        this.cType = data.cType;
+        this.glibTypeName = data.glibTypeName;
+        this.prerequisites = data.prerequisites;
+        this.methods = data.methods;
+        this.properties = data.properties;
+        this.signals = data.signals;
+        this.doc = data.doc;
+    }
+    /** @internal */
+    _setRepository(repo) {
+        this._repo = repo;
+    }
+    /** Checks if this interface has a prerequisite (direct or transitive). */
+    hasPrerequisite(qualifiedName) {
+        if (this.prerequisites.includes(qualifiedName))
+            return true;
+        if (!this._repo)
+            return false;
+        for (const prereq of this.prerequisites) {
+            const prereqIface = this._repo.resolveInterface(prereq);
+            if (prereqIface?.hasPrerequisite(qualifiedName))
+                return true;
+        }
+        return false;
+    }
+    /** Gets all prerequisites including transitive ones. */
+    getAllPrerequisites() {
+        const all = new Set(this.prerequisites);
+        if (this._repo) {
+            for (const prereq of this.prerequisites) {
+                const prereqIface = this._repo.resolveInterface(prereq);
+                if (prereqIface) {
+                    for (const p of prereqIface.getAllPrerequisites()) {
+                        all.add(p);
+                    }
                 }
             }
-            for (const callback of ns.callbacks) {
-                registry.registerCallback(ns.name, callback.name);
-            }
         }
-        return registry;
+        return [...all];
+    }
+    /** Finds a method by name. */
+    getMethod(name) {
+        return this.methods.find((m) => m.name === name) ?? null;
+    }
+    /** Finds a property by name. */
+    getProperty(name) {
+        return this.properties.find((p) => p.name === name) ?? null;
+    }
+    /** Finds a signal by name. */
+    getSignal(name) {
+        return this.signals.find((s) => s.name === name) ?? null;
     }
 }
-const STRING_TYPES = new Set(["utf8", "filename"]);
-const PRIMITIVE_TYPES = new Set([
-    "gint",
-    "guint",
-    "gint8",
-    "guint8",
-    "gint16",
-    "guint16",
-    "gint32",
-    "guint32",
-    "gint64",
-    "guint64",
-    "gfloat",
-    "gdouble",
-    "gboolean",
-    "gchar",
-    "guchar",
-    "gsize",
-    "gssize",
-    "glong",
-    "gulong",
-]);
 /**
- * Checks if a record has at least one public primitive field and all public fields are primitive.
- * Used to determine if a plain struct can be safely generated.
- * Records with only private fields are considered opaque and should not be plain structs.
+ * Normalized record (boxed type or plain struct) with helper methods.
  */
-const hasOnlyPrimitiveFields = (fields) => {
-    const publicFields = fields.filter((f) => !f.private);
-    if (publicFields.length === 0)
-        return false;
-    return publicFields.every((field) => PRIMITIVE_TYPES.has(field.type.name));
-};
+export class GirRecord {
+    name;
+    qualifiedName;
+    cType;
+    opaque;
+    disguised;
+    glibTypeName;
+    glibGetType;
+    isGtypeStructFor;
+    fields;
+    methods;
+    constructors;
+    staticFunctions;
+    doc;
+    constructor(data) {
+        this.name = data.name;
+        this.qualifiedName = data.qualifiedName;
+        this.cType = data.cType;
+        this.opaque = data.opaque;
+        this.disguised = data.disguised;
+        this.glibTypeName = data.glibTypeName;
+        this.glibGetType = data.glibGetType;
+        this.isGtypeStructFor = data.isGtypeStructFor;
+        this.fields = data.fields;
+        this.methods = data.methods;
+        this.constructors = data.constructors;
+        this.staticFunctions = data.staticFunctions;
+        this.doc = data.doc;
+    }
+    /** True if this is a GLib boxed type (has glibTypeName). */
+    isBoxed() {
+        return this.glibTypeName !== undefined;
+    }
+    /** True if this is a GType struct (vtable for a class/interface). */
+    isGtypeStruct() {
+        return this.isGtypeStructFor !== undefined;
+    }
+    /** True if this is a plain C struct (no GType, has public fields). */
+    isPlainStruct() {
+        return !this.glibTypeName && !this.opaque && this.getPublicFields().length > 0;
+    }
+    /** Gets public (non-private) fields only. */
+    getPublicFields() {
+        return this.fields.filter((f) => !f.private);
+    }
+    /** Finds a method by name. */
+    getMethod(name) {
+        return this.methods.find((m) => m.name === name) ?? null;
+    }
+    /** Finds a field by name. */
+    getField(name) {
+        return this.fields.find((f) => f.name === name) ?? null;
+    }
+    /** Finds a constructor by name. */
+    getConstructor(name) {
+        return this.constructors.find((c) => c.name === name) ?? null;
+    }
+}
 /**
- * Gets the size and alignment of a field type in bytes.
+ * Normalized enumeration with helper methods.
  */
-const getFieldSizeAndAlignment = (type) => {
-    const typeName = type.name;
-    if (["gboolean", "guint8", "gint8", "guchar", "gchar"].includes(typeName)) {
-        return { size: 1, alignment: 1 };
-    }
-    if (["gint16", "guint16", "gshort", "gushort"].includes(typeName)) {
-        return { size: 2, alignment: 2 };
+export class GirEnumeration {
+    name;
+    qualifiedName;
+    cType;
+    members;
+    doc;
+    constructor(data) {
+        this.name = data.name;
+        this.qualifiedName = data.qualifiedName;
+        this.cType = data.cType;
+        this.members = data.members;
+        this.doc = data.doc;
+    }
+    /** Finds a member by name. */
+    getMember(name) {
+        return this.members.find((m) => m.name === name) ?? null;
+    }
+    /** Finds a member by value. */
+    getMemberByValue(value) {
+        return this.members.find((m) => m.value === value) ?? null;
+    }
+    /** Gets all member names. */
+    getMemberNames() {
+        return this.members.map((m) => m.name);
     }
-    if (["gint", "guint", "gint32", "guint32", "gfloat", "float", "Quark", "GQuark"].includes(typeName)) {
-        return { size: 4, alignment: 4 };
+}
+/**
+ * Normalized enumeration member.
+ */
+export class GirEnumerationMember {
+    name;
+    value;
+    cIdentifier;
+    doc;
+    constructor(data) {
+        this.name = data.name;
+        this.value = data.value;
+        this.cIdentifier = data.cIdentifier;
+        this.doc = data.doc;
     }
-    if (["gint64", "guint64", "gdouble", "double", "glong", "gulong", "gsize", "gssize", "GType", "gpointer"].includes(typeName)) {
-        return { size: 8, alignment: 8 };
+}
+/**
+ * Normalized callback type.
+ */
+export class GirCallback {
+    name;
+    qualifiedName;
+    cType;
+    returnType;
+    parameters;
+    doc;
+    constructor(data) {
+        this.name = data.name;
+        this.qualifiedName = data.qualifiedName;
+        this.cType = data.cType;
+        this.returnType = data.returnType;
+        this.parameters = data.parameters;
+        this.doc = data.doc;
     }
-    return { size: 8, alignment: 8 };
-};
+}
 /**
- * Calculates the memory layout of a struct (size and field offsets).
+ * Normalized constant.
  */
-const calculateStructLayout = (fields) => {
-    const result = [];
-    let currentOffset = 0;
-    let maxAlignment = 1;
-    for (const field of fields) {
-        if (field.private)
-            continue;
-        const { size, alignment } = getFieldSizeAndAlignment(field.type);
-        maxAlignment = Math.max(maxAlignment, alignment);
-        currentOffset = Math.ceil(currentOffset / alignment) * alignment;
-        result.push({
-            name: field.name,
-            offset: currentOffset,
-            type: field.type.name,
-        });
-        currentOffset += size;
-    }
-    const finalSize = Math.ceil(currentOffset / maxAlignment) * maxAlignment;
-    return { size: finalSize, fields: result };
-};
-const POINTER_TYPE = { ts: "number", ffi: { type: "int", size: 64, unsigned: true } };
-const C_TYPE_MAP = new Map([
-    ["void", { ts: "void", ffi: { type: "undefined" } }],
-    ["gboolean", { ts: "boolean", ffi: { type: "boolean" } }],
-    ["gchar", { ts: "number", ffi: { type: "int", size: 8, unsigned: false } }],
-    ["guchar", { ts: "number", ffi: { type: "int", size: 8, unsigned: true } }],
-    ["gint", { ts: "number", ffi: { type: "int", size: 32, unsigned: false } }],
-    ["guint", { ts: "number", ffi: { type: "int", size: 32, unsigned: true } }],
-    ["gshort", { ts: "number", ffi: { type: "int", size: 16, unsigned: false } }],
-    ["gushort", { ts: "number", ffi: { type: "int", size: 16, unsigned: true } }],
-    ["glong", { ts: "number", ffi: { type: "int", size: 64, unsigned: false } }],
-    ["gulong", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
-    ["gint8", { ts: "number", ffi: { type: "int", size: 8, unsigned: false } }],
-    ["guint8", { ts: "number", ffi: { type: "int", size: 8, unsigned: true } }],
-    ["gint16", { ts: "number", ffi: { type: "int", size: 16, unsigned: false } }],
-    ["guint16", { ts: "number", ffi: { type: "int", size: 16, unsigned: true } }],
-    ["gint32", { ts: "number", ffi: { type: "int", size: 32, unsigned: false } }],
-    ["guint32", { ts: "number", ffi: { type: "int", size: 32, unsigned: true } }],
-    ["gint64", { ts: "number", ffi: { type: "int", size: 64, unsigned: false } }],
-    ["guint64", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
-    ["gfloat", { ts: "number", ffi: { type: "float", size: 32 } }],
-    ["gdouble", { ts: "number", ffi: { type: "float", size: 64 } }],
-    ["gsize", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
-    ["gssize", { ts: "number", ffi: { type: "int", size: 64, unsigned: false } }],
-    ["goffset", { ts: "number", ffi: { type: "int", size: 64, unsigned: false } }],
-    ["int", { ts: "number", ffi: { type: "int", size: 32, unsigned: false } }],
-    ["unsigned int", { ts: "number", ffi: { type: "int", size: 32, unsigned: true } }],
-    ["long", { ts: "number", ffi: { type: "int", size: 64, unsigned: false } }],
-    ["unsigned long", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
-    ["double", { ts: "number", ffi: { type: "float", size: 64 } }],
-    ["float", { ts: "number", ffi: { type: "float", size: 32 } }],
-    ["size_t", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
-    ["ssize_t", { ts: "number", ffi: { type: "int", size: 64, unsigned: false } }],
-    ["GType", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
-    ["GQuark", { ts: "number", ffi: { type: "int", size: 32, unsigned: true } }],
-]);
-const mapCType = (cType) => {
-    if (!cType) {
-        return POINTER_TYPE;
-    }
-    if (cType.endsWith("*")) {
-        return POINTER_TYPE;
-    }
-    const mapped = C_TYPE_MAP.get(cType);
-    if (mapped) {
-        return mapped;
-    }
-    if (cType.startsWith("const ")) {
-        return mapCType(cType.slice(6));
-    }
-    return POINTER_TYPE;
-};
-const BASIC_TYPE_MAP = new Map([
-    ["gboolean", { ts: "boolean", ffi: { type: "boolean" } }],
-    ["gchar", { ts: "number", ffi: { type: "int", size: 8, unsigned: false } }],
-    ["guchar", { ts: "number", ffi: { type: "int", size: 8, unsigned: true } }],
-    ["gint", { ts: "number", ffi: { type: "int", size: 32, unsigned: false } }],
-    ["guint", { ts: "number", ffi: { type: "int", size: 32, unsigned: true } }],
-    ["gshort", { ts: "number", ffi: { type: "int", size: 16, unsigned: false } }],
-    ["gushort", { ts: "number", ffi: { type: "int", size: 16, unsigned: true } }],
-    ["glong", { ts: "number", ffi: { type: "int", size: 64, unsigned: false } }],
-    ["gulong", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
-    ["GType", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
-    ["gint8", { ts: "number", ffi: { type: "int", size: 8, unsigned: false } }],
-    ["guint8", { ts: "number", ffi: { type: "int", size: 8, unsigned: true } }],
-    ["gint16", { ts: "number", ffi: { type: "int", size: 16, unsigned: false } }],
-    ["guint16", { ts: "number", ffi: { type: "int", size: 16, unsigned: true } }],
-    ["gint32", { ts: "number", ffi: { type: "int", size: 32, unsigned: false } }],
-    ["guint32", { ts: "number", ffi: { type: "int", size: 32, unsigned: true } }],
-    ["gint64", { ts: "number", ffi: { type: "int", size: 64, unsigned: false } }],
-    ["guint64", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
-    ["gfloat", { ts: "number", ffi: { type: "float", size: 32 } }],
-    ["gdouble", { ts: "number", ffi: { type: "float", size: 64 } }],
-    ["gpointer", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
-    ["gconstpointer", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
-    ["gsize", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
-    ["gssize", { ts: "number", ffi: { type: "int", size: 64, unsigned: false } }],
-    ["goffset", { ts: "number", ffi: { type: "int", size: 64, unsigned: false } }],
-    ["guintptr", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
-    ["gintptr", { ts: "number", ffi: { type: "int", size: 64, unsigned: false } }],
-    ["pid_t", { ts: "number", ffi: { type: "int", size: 32, unsigned: false } }],
-    ["uid_t", { ts: "number", ffi: { type: "int", size: 32, unsigned: true } }],
-    ["gid_t", { ts: "number", ffi: { type: "int", size: 32, unsigned: true } }],
-    ["time_t", { ts: "number", ffi: { type: "int", size: 64, unsigned: false } }],
-    ["Quark", { ts: "number", ffi: { type: "int", size: 32, unsigned: true } }],
-    ["GLib.Quark", { ts: "number", ffi: { type: "int", size: 32, unsigned: true } }],
-    ["TimeSpan", { ts: "number", ffi: { type: "int", size: 64, unsigned: false } }],
-    ["GLib.TimeSpan", { ts: "number", ffi: { type: "int", size: 64, unsigned: false } }],
-    ["DateDay", { ts: "number", ffi: { type: "int", size: 8, unsigned: true } }],
-    ["GLib.DateDay", { ts: "number", ffi: { type: "int", size: 8, unsigned: true } }],
-    ["DateYear", { ts: "number", ffi: { type: "int", size: 32, unsigned: true } }],
-    ["GLib.DateYear", { ts: "number", ffi: { type: "int", size: 32, unsigned: true } }],
-    ["DateMonth", { ts: "number", ffi: { type: "int", size: 32, unsigned: false } }],
-    ["GLib.DateMonth", { ts: "number", ffi: { type: "int", size: 32, unsigned: false } }],
-    ["Pid", { ts: "number", ffi: { type: "int", size: 32, unsigned: false } }],
-    ["GLib.Pid", { ts: "number", ffi: { type: "int", size: 32, unsigned: false } }],
-    ["void", { ts: "void", ffi: { type: "undefined" } }],
-    ["none", { ts: "void", ffi: { type: "undefined" } }],
-    ["int", { ts: "number", ffi: { type: "int", size: 32, unsigned: false } }],
-    ["uint", { ts: "number", ffi: { type: "int", size: 32, unsigned: true } }],
-    ["long", { ts: "number", ffi: { type: "int", size: 64, unsigned: false } }],
-    ["ulong", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
-    ["size_t", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
-    ["ssize_t", { ts: "number", ffi: { type: "int", size: 64, unsigned: false } }],
-    ["double", { ts: "number", ffi: { type: "float", size: 64 } }],
-    ["float", { ts: "number", ffi: { type: "float", size: 32 } }],
-    ["GLib.DestroyNotify", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
-    ["DestroyNotify", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
-    ["GLib.FreeFunc", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
-    ["FreeFunc", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
-]);
+export class GirConstant {
+    name;
+    qualifiedName;
+    cType;
+    value;
+    type;
+    doc;
+    constructor(data) {
+        this.name = data.name;
+        this.qualifiedName = data.qualifiedName;
+        this.cType = data.cType;
+        this.value = data.value;
+        this.type = data.type;
+        this.doc = data.doc;
+    }
+}
 /**
- * Maps GIR types to TypeScript and FFI type representations.
- *
- * Handles conversion of GIR type information into:
- * - TypeScript type strings for generated declarations
- * - FFI type descriptors for runtime marshalling
- *
- * Supports callbacks for tracking type usage dependencies.
- *
- * @example
- * ```tsx
- * const mapper = new TypeMapper();
- * mapper.registerEnum("Orientation", "Orientation");
- * mapper.setTypeRegistry(registry, "Gtk");
- *
- * const result = mapper.mapType({ name: "utf8" });
- * // { ts: "string", ffi: { type: "string", borrowed: false } }
- * ```
+ * Normalized method with helper methods.
  */
-export class TypeMapper {
-    enumNames = new Set();
-    enumTransforms = new Map();
-    flagsNames = new Set();
-    flagsTransforms = new Map();
-    recordNames = new Set();
-    recordTransforms = new Map();
-    recordGlibTypes = new Map();
-    skippedClasses = new Set();
-    onEnumUsed;
-    onRecordUsed;
-    onExternalTypeUsed;
-    onSameNamespaceClassUsed;
-    typeRegistry;
-    currentNamespace;
-    forceExternalNamespace;
-    /**
-     * Registers an enumeration for type mapping.
-     *
-     * @param originalName - The GIR enum name
-     * @param transformedName - Optional transformed TypeScript name
-     */
-    registerEnum(originalName, transformedName) {
-        this.enumNames.add(originalName);
-        if (transformedName) {
-            this.enumTransforms.set(originalName, transformedName);
+export class GirMethod {
+    name;
+    cIdentifier;
+    returnType;
+    parameters;
+    throws;
+    doc;
+    returnDoc;
+    /** For async methods, the name of the corresponding finish function */
+    finishFunc;
+    constructor(data) {
+        this.name = data.name;
+        this.cIdentifier = data.cIdentifier;
+        this.returnType = data.returnType;
+        this.parameters = data.parameters;
+        this.throws = data.throws;
+        this.doc = data.doc;
+        this.returnDoc = data.returnDoc;
+        this.finishFunc = data.finishFunc;
+    }
+    /** True if this follows the async/finish pattern. */
+    isAsync() {
+        return this.name.endsWith("_async") || this.parameters.some((p) => p.scope === "async");
+    }
+    /** True if this is a _finish method for an async operation. */
+    isAsyncFinish() {
+        return this.name.endsWith("_finish");
+    }
+    /** Gets the corresponding _finish method name if this is async. */
+    getFinishMethodName() {
+        if (this.name.endsWith("_async")) {
+            return this.name.replace(/_async$/, "_finish");
         }
+        return null;
     }
-    /**
-     * Registers a flags (bitfield) type for type mapping.
-     *
-     * @param originalName - The GIR flags name
-     * @param transformedName - Optional transformed TypeScript name
-     */
-    registerFlags(originalName, transformedName) {
-        this.flagsNames.add(originalName);
-        if (transformedName) {
-            this.flagsTransforms.set(originalName, transformedName);
-        }
+    /** Gets required (non-optional, non-nullable) parameters. */
+    getRequiredParameters() {
+        return this.parameters.filter((p) => !p.optional && !p.nullable && p.direction === "in");
     }
-    /**
-     * Registers a record for type mapping.
-     *
-     * @param originalName - The GIR record name
-     * @param transformedName - Optional transformed TypeScript name
-     * @param glibTypeName - Optional GLib type name for boxed type marshalling
-     */
-    registerRecord(originalName, transformedName, glibTypeName) {
-        this.recordNames.add(originalName);
-        if (transformedName) {
-            this.recordTransforms.set(originalName, transformedName);
-        }
-        if (glibTypeName) {
-            this.recordGlibTypes.set(originalName, glibTypeName);
-        }
+    /** Gets optional parameters. */
+    getOptionalParameters() {
+        return this.parameters.filter((p) => p.optional || p.nullable);
     }
-    setEnumUsageCallback(callback) {
-        this.onEnumUsed = callback ?? undefined;
-    }
-    getEnumUsageCallback() {
-        return this.onEnumUsed ?? null;
-    }
-    setRecordUsageCallback(callback) {
-        this.onRecordUsed = callback ?? undefined;
-    }
-    getRecordUsageCallback() {
-        return this.onRecordUsed ?? null;
-    }
-    setExternalTypeUsageCallback(callback) {
-        this.onExternalTypeUsed = callback ?? undefined;
-    }
-    getExternalTypeUsageCallback() {
-        return this.onExternalTypeUsed ?? null;
-    }
-    setSameNamespaceClassUsageCallback(callback) {
-        this.onSameNamespaceClassUsed = callback ?? undefined;
-    }
-    getSameNamespaceClassUsageCallback() {
-        return this.onSameNamespaceClassUsed ?? null;
-    }
-    /**
-     * Sets the type registry for cross-namespace type resolution.
-     *
-     * @param registry - The type registry to use
-     * @param currentNamespace - The current namespace being processed
-     */
-    setTypeRegistry(registry, currentNamespace) {
-        this.typeRegistry = registry;
-        this.currentNamespace = currentNamespace;
-    }
-    setForceExternalNamespace(namespace) {
-        this.forceExternalNamespace = namespace ?? undefined;
-    }
-    registerSkippedClass(name) {
-        this.skippedClasses.add(name);
-    }
-    clearSkippedClasses() {
-        this.skippedClasses.clear();
-    }
-    /**
-     * Maps a GIR type to TypeScript and FFI representations.
-     *
-     * @param girType - The GIR type to map
-     * @param isReturn - Whether this is a return type (affects ownership)
-     * @param parentTransferOwnership - Transfer ownership from parent (used for array elements)
-     * @returns The mapped type with TypeScript and FFI descriptors
-     */
-    mapType(girType, isReturn = false, parentTransferOwnership) {
-        if (girType.isArray || girType.name === "array") {
-            const listType = girType.cType?.includes("GSList")
-                ? "gslist"
-                : girType.cType?.includes("GList")
-                    ? "glist"
-                    : undefined;
-            if (girType.elementType) {
-                const elementTransferOwnership = girType.transferOwnership ?? parentTransferOwnership;
-                const elementType = this.mapType(girType.elementType, isReturn, elementTransferOwnership);
-                return {
-                    ts: `${elementType.ts}[]`,
-                    ffi: listType
-                        ? { type: "array", itemType: elementType.ffi, listType, borrowed: isReturn }
-                        : { type: "array", itemType: elementType.ffi },
-                };
-            }
-            return {
-                ts: `unknown[]`,
-                ffi: listType
-                    ? { type: "array", itemType: { type: "undefined" }, listType, borrowed: isReturn }
-                    : { type: "array", itemType: { type: "undefined" } },
-            };
-        }
-        if (STRING_TYPES.has(girType.name)) {
-            const effectiveTransferOwnership = girType.transferOwnership ?? parentTransferOwnership;
-            const borrowed = effectiveTransferOwnership === "none";
-            return {
-                ts: "string",
-                ffi: { type: "string", borrowed },
-            };
-        }
-        const basicType = BASIC_TYPE_MAP.get(girType.name);
-        if (basicType) {
-            return basicType;
-        }
-        if (this.typeRegistry && this.currentNamespace && !girType.name.includes(".")) {
-            const registered = this.typeRegistry.resolveInNamespace(girType.name, this.currentNamespace);
-            if (registered) {
-                const isExternal = registered.namespace !== this.currentNamespace ||
-                    registered.namespace === this.forceExternalNamespace;
-                const qualifiedName = isExternal
-                    ? `${registered.namespace}.${registered.transformedName}`
-                    : registered.transformedName;
-                const externalType = isExternal
-                    ? {
-                        namespace: registered.namespace,
-                        name: registered.name,
-                        transformedName: registered.transformedName,
-                        kind: registered.kind,
-                    }
-                    : undefined;
-                if (isExternal) {
-                    this.onExternalTypeUsed?.(externalType);
-                }
-                else if (registered.kind === "class" || registered.kind === "interface") {
-                    if (this.skippedClasses.has(registered.name)) {
-                        return {
-                            ts: "unknown",
-                            ffi: { type: "gobject", borrowed: isReturn },
-                        };
-                    }
-                    this.onSameNamespaceClassUsed?.(registered.transformedName, registered.name);
-                }
-                else if (registered.kind === "enum" || registered.kind === "flags") {
-                    this.onEnumUsed?.(registered.transformedName);
-                }
-                else if (registered.kind === "record") {
-                    this.onRecordUsed?.(registered.transformedName);
-                }
-                if (registered.kind === "enum") {
-                    return {
-                        ts: qualifiedName,
-                        ffi: { type: "int", size: 32, unsigned: false },
-                        externalType,
-                    };
-                }
-                if (registered.kind === "flags") {
-                    return {
-                        ts: qualifiedName,
-                        ffi: { type: "int", size: 32, unsigned: true },
-                        externalType,
-                    };
-                }
-                if (registered.kind === "record") {
-                    if (registered.name === "Variant" && registered.namespace === "GLib") {
-                        return {
-                            ts: qualifiedName,
-                            ffi: { type: "gvariant", borrowed: isReturn },
-                            externalType,
-                            kind: registered.kind,
-                        };
-                    }
-                    if (registered.isPlainStruct) {
-                        return {
-                            ts: qualifiedName,
-                            ffi: {
-                                type: "struct",
-                                borrowed: isReturn,
-                                innerType: registered.transformedName,
-                                size: registered.structSize,
-                            },
-                            externalType,
-                            kind: registered.kind,
-                        };
-                    }
-                    return {
-                        ts: qualifiedName,
-                        ffi: {
-                            type: "boxed",
-                            borrowed: isReturn,
-                            innerType: registered.glibTypeName ?? registered.transformedName,
-                            lib: registered.sharedLibrary,
-                            getTypeFn: registered.glibGetType,
-                        },
-                        externalType,
-                        kind: registered.kind,
-                    };
-                }
-                if (registered.kind === "callback") {
-                    return POINTER_TYPE;
-                }
-                if (registered.name === "ParamSpec" && registered.namespace === "GObject") {
-                    return {
-                        ts: qualifiedName,
-                        ffi: { type: "gparam", borrowed: isReturn },
-                        externalType,
-                        kind: registered.kind,
-                    };
-                }
-                return {
-                    ts: qualifiedName,
-                    ffi: { type: "gobject", borrowed: isReturn },
-                    externalType,
-                    kind: registered.kind,
-                };
-            }
-        }
-        if (this.enumNames.has(girType.name)) {
-            const transformedName = this.enumTransforms.get(girType.name) ?? girType.name;
-            this.onEnumUsed?.(transformedName);
-            return {
-                ts: transformedName,
-                ffi: { type: "int", size: 32, unsigned: false },
-            };
-        }
-        if (this.flagsNames.has(girType.name)) {
-            const transformedName = this.flagsTransforms.get(girType.name) ?? girType.name;
-            this.onEnumUsed?.(transformedName);
-            return {
-                ts: transformedName,
-                ffi: { type: "int", size: 32, unsigned: true },
-            };
-        }
-        if (this.recordNames.has(girType.name)) {
-            const transformedName = this.recordTransforms.get(girType.name) ?? girType.name;
-            const glibTypeName = this.recordGlibTypes.get(girType.name) ?? transformedName;
-            this.onRecordUsed?.(transformedName);
-            return {
-                ts: transformedName,
-                ffi: { type: "boxed", borrowed: isReturn, innerType: glibTypeName },
-            };
-        }
-        if (girType.name.includes(".")) {
-            const [ns, typeName] = girType.name.split(".", 2);
-            if (typeName && ns === this.currentNamespace) {
-                if (this.enumNames.has(typeName)) {
-                    const transformedName = this.enumTransforms.get(typeName) ?? typeName;
-                    this.onEnumUsed?.(transformedName);
-                    return {
-                        ts: transformedName,
-                        ffi: { type: "int", size: 32, unsigned: false },
-                    };
-                }
-                if (this.flagsNames.has(typeName)) {
-                    const transformedName = this.flagsTransforms.get(typeName) ?? typeName;
-                    this.onEnumUsed?.(transformedName);
-                    return {
-                        ts: transformedName,
-                        ffi: { type: "int", size: 32, unsigned: true },
-                    };
-                }
-                if (this.recordNames.has(typeName)) {
-                    const transformedName = this.recordTransforms.get(typeName) ?? typeName;
-                    const glibTypeName = this.recordGlibTypes.get(typeName) ?? transformedName;
-                    this.onRecordUsed?.(transformedName);
-                    return {
-                        ts: transformedName,
-                        ffi: { type: "boxed", borrowed: isReturn, innerType: glibTypeName },
-                    };
-                }
-            }
-            if (this.typeRegistry && ns && typeName) {
-                const registered = this.typeRegistry.resolve(girType.name);
-                if (registered) {
-                    const isExternal = registered.namespace !== this.currentNamespace ||
-                        registered.namespace === this.forceExternalNamespace;
-                    const qualifiedName = isExternal
-                        ? `${registered.namespace}.${registered.transformedName}`
-                        : registered.transformedName;
-                    const externalType = {
-                        namespace: registered.namespace,
-                        name: registered.name,
-                        transformedName: registered.transformedName,
-                        kind: registered.kind,
-                    };
-                    if (isExternal) {
-                        this.onExternalTypeUsed?.(externalType);
-                    }
-                    if (registered.kind === "enum") {
-                        return {
-                            ts: qualifiedName,
-                            ffi: { type: "int", size: 32, unsigned: false },
-                            externalType: isExternal ? externalType : undefined,
-                        };
-                    }
-                    if (registered.kind === "flags") {
-                        return {
-                            ts: qualifiedName,
-                            ffi: { type: "int", size: 32, unsigned: true },
-                            externalType: isExternal ? externalType : undefined,
-                        };
-                    }
-                    if (registered.kind === "record") {
-                        if (registered.name === "Variant" && registered.namespace === "GLib") {
-                            return {
-                                ts: qualifiedName,
-                                ffi: { type: "gvariant", borrowed: isReturn },
-                                externalType: isExternal ? externalType : undefined,
-                            };
-                        }
-                        if (registered.isPlainStruct) {
-                            return {
-                                ts: qualifiedName,
-                                ffi: {
-                                    type: "struct",
-                                    borrowed: isReturn,
-                                    innerType: registered.transformedName,
-                                    size: registered.structSize,
-                                },
-                                externalType: isExternal ? externalType : undefined,
-                                kind: registered.kind,
-                            };
-                        }
-                        return {
-                            ts: qualifiedName,
-                            ffi: {
-                                type: "boxed",
-                                borrowed: isReturn,
-                                innerType: registered.glibTypeName ?? registered.transformedName,
-                                lib: registered.sharedLibrary,
-                                getTypeFn: registered.glibGetType,
-                            },
-                            externalType: isExternal ? externalType : undefined,
-                        };
-                    }
-                    if (registered.kind === "callback") {
-                        return POINTER_TYPE;
-                    }
-                    if (registered.name === "ParamSpec" && registered.namespace === "GObject") {
-                        return {
-                            ts: qualifiedName,
-                            ffi: { type: "gparam", borrowed: isReturn },
-                            externalType: isExternal ? externalType : undefined,
-                            kind: registered.kind,
-                        };
-                    }
-                    return {
-                        ts: qualifiedName,
-                        ffi: { type: "gobject", borrowed: isReturn },
-                        externalType: isExternal ? externalType : undefined,
-                        kind: registered.kind,
-                    };
-                }
-            }
-            return mapCType(girType.cType);
-        }
-        if (this.typeRegistry && this.currentNamespace) {
-            const registered = this.typeRegistry.resolveInNamespace(girType.name, this.currentNamespace);
-            if (registered) {
-                const isExternal = registered.namespace !== this.currentNamespace ||
-                    registered.namespace === this.forceExternalNamespace;
-                const qualifiedName = isExternal
-                    ? `${registered.namespace}.${registered.transformedName}`
-                    : registered.transformedName;
-                const externalType = isExternal
-                    ? {
-                        namespace: registered.namespace,
-                        name: registered.name,
-                        transformedName: registered.transformedName,
-                        kind: registered.kind,
-                    }
-                    : undefined;
-                if (isExternal) {
-                    this.onExternalTypeUsed?.(externalType);
-                }
-                else if (registered.kind === "class" || registered.kind === "interface") {
-                    if (this.skippedClasses.has(registered.name)) {
-                        return {
-                            ts: "unknown",
-                            ffi: { type: "gobject", borrowed: isReturn },
-                        };
-                    }
-                    this.onSameNamespaceClassUsed?.(registered.transformedName, registered.name);
-                }
-                if (registered.kind === "enum") {
-                    return {
-                        ts: qualifiedName,
-                        ffi: { type: "int", size: 32, unsigned: false },
-                        externalType,
-                    };
-                }
-                if (registered.kind === "flags") {
-                    return {
-                        ts: qualifiedName,
-                        ffi: { type: "int", size: 32, unsigned: true },
-                        externalType,
-                    };
-                }
-                if (registered.kind === "record") {
-                    if (registered.isPlainStruct) {
-                        return {
-                            ts: qualifiedName,
-                            ffi: {
-                                type: "struct",
-                                borrowed: isReturn,
-                                innerType: registered.transformedName,
-                                size: registered.structSize,
-                            },
-                            externalType,
-                            kind: registered.kind,
-                        };
-                    }
-                    return {
-                        ts: qualifiedName,
-                        ffi: {
-                            type: "boxed",
-                            borrowed: isReturn,
-                            innerType: registered.glibTypeName ?? registered.transformedName,
-                            lib: registered.sharedLibrary,
-                            getTypeFn: registered.glibGetType,
-                        },
-                        externalType,
-                        kind: registered.kind,
-                    };
-                }
-                if (registered.kind === "callback") {
-                    return POINTER_TYPE;
-                }
-                if (registered.name === "ParamSpec" && registered.namespace === "GObject") {
-                    return {
-                        ts: qualifiedName,
-                        ffi: { type: "gparam", borrowed: isReturn },
-                        externalType,
-                        kind: registered.kind,
-                    };
-                }
-                return {
-                    ts: qualifiedName,
-                    ffi: { type: "gobject", borrowed: isReturn },
-                    externalType,
-                    kind: registered.kind,
-                };
-            }
-        }
-        return mapCType(girType.cType);
-    }
-    isCallback(typeName) {
-        if (this.typeRegistry) {
-            const resolved = this.currentNamespace
-                ? this.typeRegistry.resolveInNamespace(typeName, this.currentNamespace)
-                : this.typeRegistry.resolve(typeName);
-            return resolved?.kind === "callback";
-        }
-        return false;
+    /** True if any parameter is an out parameter. */
+    hasOutParameters() {
+        return this.parameters.some((p) => p.direction === "out" || p.direction === "inout");
     }
-    /**
-     * Maps a function parameter to TypeScript and FFI representations.
-     *
-     * Handles special cases like out parameters, callbacks, and
-     * ownership transfer.
-     *
-     * @param param - The GIR parameter to map
-     * @returns The mapped type with TypeScript and FFI descriptors
-     */
-    mapParameter(param) {
-        if (param.direction === "out" || param.direction === "inout") {
-            const innerType = this.mapType(param.type);
-            const isBoxedOrGObjectOrStruct = innerType.ffi.type === "boxed" || innerType.ffi.type === "gobject" || innerType.ffi.type === "struct";
-            if (param.callerAllocates && isBoxedOrGObjectOrStruct) {
-                return {
-                    ...innerType,
-                    ffi: {
-                        ...innerType.ffi,
-                        borrowed: true,
-                    },
-                };
-            }
-            if (!isBoxedOrGObjectOrStruct) {
-                return {
-                    ts: `Ref<${innerType.ts}>`,
-                    ffi: {
-                        type: "ref",
-                        innerType: innerType.ffi,
-                    },
-                };
-            }
-            return {
-                ts: `Ref<${innerType.ts}>`,
-                ffi: {
-                    type: "ref",
-                    innerType: innerType.ffi,
-                },
-                externalType: innerType.externalType,
-                kind: innerType.kind,
-            };
-        }
-        if (param.type.name === "Gio.AsyncReadyCallback") {
-            return {
-                ts: "(source: unknown, result: unknown) => void",
-                ffi: {
-                    type: "callback",
-                    trampoline: "asyncReady",
-                    sourceType: { type: "gobject", borrowed: true },
-                    resultType: { type: "gobject", borrowed: true },
-                },
-            };
-        }
-        if (param.type.name === "GLib.DestroyNotify" || param.type.name === "DestroyNotify") {
-            return {
-                ts: "() => void",
-                ffi: {
-                    type: "callback",
-                    trampoline: "destroy",
-                },
-            };
-        }
-        if (param.type.name === "Gtk.DrawingAreaDrawFunc" || param.type.name === "DrawingAreaDrawFunc") {
-            this.onExternalTypeUsed?.({
-                namespace: "cairo",
-                name: "Context",
-                transformedName: "Context",
-                kind: "record",
-            });
-            this.onSameNamespaceClassUsed?.("DrawingArea", "DrawingArea");
-            return {
-                ts: "(self: DrawingArea, cr: cairo.Context, width: number, height: number) => void",
-                ffi: {
-                    type: "callback",
-                    trampoline: "drawFunc",
-                    argTypes: [
-                        { type: "gobject", borrowed: true },
-                        {
-                            type: "boxed",
-                            borrowed: true,
-                            innerType: "CairoContext",
-                            lib: "libcairo-gobject.so.2",
-                            getTypeFn: "cairo_gobject_context_get_type",
-                        },
-                        { type: "int", size: 32, unsigned: false },
-                        { type: "int", size: 32, unsigned: false },
-                    ],
-                },
-            };
-        }
-        if (param.type.name === "Gtk.ShortcutFunc" || param.type.name === "ShortcutFunc") {
-            this.onSameNamespaceClassUsed?.("Widget", "Widget");
-            this.onExternalTypeUsed?.({
-                namespace: "GLib",
-                name: "Variant",
-                transformedName: "Variant",
-                kind: "record",
-            });
-            return {
-                ts: "(widget: Widget, args: GLib.Variant | null) => boolean",
-                ffi: {
-                    type: "callback",
-                    trampoline: "shortcutFunc",
-                    argTypes: [
-                        { type: "gobject", borrowed: true },
-                        { type: "gvariant", borrowed: true },
-                    ],
-                    returnType: { type: "boolean" },
-                },
-            };
-        }
-        if (param.type.name === "Gtk.TreeListModelCreateModelFunc" ||
-            param.type.name === "TreeListModelCreateModelFunc") {
-            this.onExternalTypeUsed?.({
-                namespace: "GObject",
-                name: "Object",
-                transformedName: "GObject",
-                kind: "class",
-            });
-            this.onExternalTypeUsed?.({
-                namespace: "Gio",
-                name: "ListModel",
-                transformedName: "ListModel",
-                kind: "interface",
-            });
-            return {
-                ts: "(item: GObject.GObject) => Gio.ListModel | null",
-                ffi: {
-                    type: "callback",
-                    trampoline: "treeListModelCreateFunc",
-                    argTypes: [{ type: "gobject", borrowed: true }],
-                    returnType: { type: "gobject", borrowed: true },
-                },
-            };
-        }
-        if (param.type.name === "GLib.Closure" || this.isCallback(param.type.name)) {
-            return {
-                ts: "(...args: unknown[]) => unknown",
-                ffi: { type: "callback" },
-            };
-        }
-        const mapped = this.mapType(param.type, false, param.transferOwnership);
-        const isObjectType = mapped.ffi.type === "gobject" || mapped.ffi.type === "boxed";
-        const isTransferFull = param.transferOwnership === "full";
-        const isTransferNone = param.transferOwnership === "none" || param.transferOwnership === undefined;
-        if (isObjectType && isTransferFull) {
-            return {
-                ts: mapped.ts,
-                ffi: { ...mapped.ffi, borrowed: false },
-                externalType: mapped.externalType,
-                kind: mapped.kind,
-            };
-        }
-        if (isObjectType && isTransferNone) {
-            return {
-                ts: mapped.ts,
-                ffi: { ...mapped.ffi, borrowed: true },
-                externalType: mapped.externalType,
-                kind: mapped.kind,
-            };
-        }
-        return mapped;
-    }
-    isClosureTarget(paramIndex, allParams) {
-        const trampolineCallbacks = [
-            "Gio.AsyncReadyCallback",
-            "Gtk.DrawingAreaDrawFunc",
-            "DrawingAreaDrawFunc",
-            "GLib.CompareDataFunc",
-            "CompareDataFunc",
-            "GLib.SourceFunc",
-            "SourceFunc",
-            "Gtk.TickCallback",
-            "TickCallback",
-            "Gtk.ShortcutFunc",
-            "ShortcutFunc",
-            "Gtk.TreeListModelCreateModelFunc",
-            "TreeListModelCreateModelFunc",
-        ];
-        return allParams.some((p) => trampolineCallbacks.includes(p.type.name) && (p.closure === paramIndex || p.destroy === paramIndex));
-    }
-    isNullable(param) {
-        return param.nullable === true || param.optional === true;
-    }
-    hasUnsupportedCallback(param) {
-        const supportedCallbacks = [
-            "Gio.AsyncReadyCallback",
-            "GLib.DestroyNotify",
-            "DestroyNotify",
-            "Gtk.DrawingAreaDrawFunc",
-            "DrawingAreaDrawFunc",
-            "Gtk.ShortcutFunc",
-            "ShortcutFunc",
-            "Gtk.TreeListModelCreateModelFunc",
-            "TreeListModelCreateModelFunc",
-        ];
-        if (supportedCallbacks.includes(param.type.name)) {
-            return false;
-        }
-        return param.type.name === "GLib.Closure" || this.isCallback(param.type.name);
+    /** Gets out parameters only. */
+    getOutParameters() {
+        return this.parameters.filter((p) => p.direction === "out" || p.direction === "inout");
+    }
+}
+/**
+ * Normalized constructor.
+ */
+export class GirConstructor {
+    name;
+    cIdentifier;
+    returnType;
+    parameters;
+    throws;
+    doc;
+    returnDoc;
+    constructor(data) {
+        this.name = data.name;
+        this.cIdentifier = data.cIdentifier;
+        this.returnType = data.returnType;
+        this.parameters = data.parameters;
+        this.throws = data.throws;
+        this.doc = data.doc;
+        this.returnDoc = data.returnDoc;
+    }
+    /** Gets required (non-optional, non-nullable) parameters. */
+    getRequiredParameters() {
+        return this.parameters.filter((p) => !p.optional && !p.nullable && p.direction === "in");
+    }
+}
+/**
+ * Normalized standalone function.
+ */
+export class GirFunction {
+    name;
+    cIdentifier;
+    returnType;
+    parameters;
+    throws;
+    doc;
+    returnDoc;
+    constructor(data) {
+        this.name = data.name;
+        this.cIdentifier = data.cIdentifier;
+        this.returnType = data.returnType;
+        this.parameters = data.parameters;
+        this.throws = data.throws;
+        this.doc = data.doc;
+        this.returnDoc = data.returnDoc;
+    }
+    /** True if this follows the async/finish pattern. */
+    isAsync() {
+        return this.name.endsWith("_async") || this.parameters.some((p) => p.scope === "async");
+    }
+    /** Gets required parameters. */
+    getRequiredParameters() {
+        return this.parameters.filter((p) => !p.optional && !p.nullable && p.direction === "in");
+    }
+}
+/**
+ * Normalized parameter with helper methods.
+ */
+export class GirParameter {
+    name;
+    type;
+    direction;
+    callerAllocates;
+    nullable;
+    optional;
+    scope;
+    closure;
+    destroy;
+    transferOwnership;
+    doc;
+    constructor(data) {
+        this.name = data.name;
+        this.type = data.type;
+        this.direction = data.direction;
+        this.callerAllocates = data.callerAllocates;
+        this.nullable = data.nullable;
+        this.optional = data.optional;
+        this.scope = data.scope;
+        this.closure = data.closure;
+        this.destroy = data.destroy;
+        this.transferOwnership = data.transferOwnership;
+        this.doc = data.doc;
+    }
+    /** True if this is an input parameter. */
+    isIn() {
+        return this.direction === "in";
+    }
+    /** True if this is an output parameter. */
+    isOut() {
+        return this.direction === "out" || this.direction === "inout";
+    }
+    /** True if this is a callback parameter (has scope). */
+    isCallback() {
+        return this.scope !== undefined;
+    }
+    /** True if this is the user_data for a callback. */
+    isClosureData() {
+        return this.closure !== undefined;
+    }
+    /** True if this is a destroy notify for a callback. */
+    isDestroyNotify() {
+        return this.destroy !== undefined;
+    }
+    /** True if caller must allocate memory for this out param. */
+    requiresCallerAllocation() {
+        return this.callerAllocates && this.isOut();
+    }
+}
+/**
+ * Normalized property with helper methods.
+ */
+export class GirProperty {
+    name;
+    type;
+    readable;
+    writable;
+    constructOnly;
+    hasDefault;
+    getter;
+    setter;
+    doc;
+    constructor(data) {
+        this.name = data.name;
+        this.type = data.type;
+        this.readable = data.readable;
+        this.writable = data.writable;
+        this.constructOnly = data.constructOnly;
+        this.hasDefault = data.hasDefault;
+        this.getter = data.getter;
+        this.setter = data.setter;
+        this.doc = data.doc;
+    }
+    /** True if readable but not writable. */
+    isReadOnly() {
+        return this.readable && !this.writable;
+    }
+    /** True if writable but not readable. */
+    isWriteOnly() {
+        return this.writable && !this.readable;
+    }
+    /** True if can only be set during construction. */
+    isConstructOnly() {
+        return this.constructOnly;
+    }
+    /** True if has both getter and setter methods. */
+    hasAccessors() {
+        return this.getter !== undefined && this.setter !== undefined;
+    }
+}
+/**
+ * Normalized signal with helper methods.
+ */
+export class GirSignal {
+    name;
+    when;
+    returnType;
+    parameters;
+    doc;
+    constructor(data) {
+        this.name = data.name;
+        this.when = data.when;
+        this.returnType = data.returnType;
+        this.parameters = data.parameters;
+        this.doc = data.doc;
+    }
+    /** True if the signal returns a value. */
+    hasReturnValue() {
+        return this.returnType !== null && !this.returnType.isVoid();
+    }
+}
+/**
+ * Normalized field.
+ */
+export class GirField {
+    name;
+    type;
+    writable;
+    readable;
+    private;
+    doc;
+    constructor(data) {
+        this.name = data.name;
+        this.type = data.type;
+        this.writable = data.writable;
+        this.readable = data.readable;
+        this.private = data.private;
+        this.doc = data.doc;
+    }
+}
+/**
+ * Normalized type reference with helper methods.
+ */
+export class GirType {
+    /** Type name - either a QualifiedName or an intrinsic type string */
+    name;
+    cType;
+    isArray;
+    elementType;
+    typeParameters;
+    containerType;
+    transferOwnership;
+    nullable;
+    constructor(data) {
+        this.name = data.name;
+        this.cType = data.cType;
+        this.isArray = data.isArray;
+        this.elementType = data.elementType;
+        this.typeParameters = data.typeParameters ?? [];
+        this.containerType = data.containerType;
+        this.transferOwnership = data.transferOwnership;
+        this.nullable = data.nullable;
+    }
+    /** True if this is an intrinsic/primitive type. */
+    isIntrinsic() {
+        return typeof this.name === "string" && isIntrinsicType(this.name);
+    }
+    /** True if this is a string type (utf8 or filename). */
+    isString() {
+        return typeof this.name === "string" && isStringType(this.name);
+    }
+    /** True if this is a numeric type. */
+    isNumeric() {
+        return typeof this.name === "string" && isNumericType(this.name);
+    }
+    /** True if this is a boolean type. */
+    isBoolean() {
+        return this.name === "gboolean";
+    }
+    /** True if this is void. */
+    isVoid() {
+        return typeof this.name === "string" && isVoidType(this.name);
+    }
+    /** True if this is GVariant. */
+    isVariant() {
+        return this.name === "GVariant";
+    }
+    /** True if this is GParamSpec. */
+    isParamSpec() {
+        return this.name === "GParamSpec";
+    }
+    /** True if this is a GHashTable container. */
+    isHashTable() {
+        return this.containerType === "ghashtable";
+    }
+    /** True if this is a GPtrArray container. */
+    isPtrArray() {
+        return this.containerType === "gptrarray";
+    }
+    /** True if this is a GArray container. */
+    isGArray() {
+        return this.containerType === "garray";
+    }
+    /** True if this is a GList or GSList container. */
+    isList() {
+        return this.containerType === "glist" || this.containerType === "gslist";
+    }
+    /** True if this is any generic container type. */
+    isGenericContainer() {
+        return this.containerType !== undefined;
+    }
+    /** Gets the key type for GHashTable, or null for other types. */
+    getKeyType() {
+        if (!this.isHashTable() || this.typeParameters.length < 1)
+            return null;
+        return this.typeParameters[0] ?? null;
+    }
+    /** Gets the value type for GHashTable, or null for other types. */
+    getValueType() {
+        if (!this.isHashTable() || this.typeParameters.length < 2)
+            return null;
+        return this.typeParameters[1] ?? null;
+    }
+    /** Gets the namespace part of a qualified name, or null for intrinsics. */
+    getNamespace() {
+        if (this.isIntrinsic())
+            return null;
+        const qn = this.name;
+        const dot = qn.indexOf(".");
+        return dot >= 0 ? qn.slice(0, dot) : null;
+    }
+    /** Gets the simple name part (without namespace). */
+    getSimpleName() {
+        if (this.isIntrinsic())
+            return this.name;
+        const qn = this.name;
+        const dot = qn.indexOf(".");
+        return dot >= 0 ? qn.slice(dot + 1) : qn;
     }
 }