@gtkx/gir 0.10.5 → 0.11.1

package/dist/types.d.ts

@@ -1,536 +1,570 @@
 /**
- * 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
- */
-import { toCamelCase, toPascalCase } from "./naming.js";
-export { toCamelCase, toPascalCase };
-/**
- * Represents a parsed GIR namespace (library).
- *
- * Contains all type definitions from a single GIR file, including
- * classes, interfaces, functions, enums, records, and callbacks.
- */
-export type GirNamespace = {
-    name: string;
-    version: string;
-    sharedLibrary: string;
-    cPrefix: string;
-    classes: GirClass[];
-    interfaces: GirInterface[];
-    functions: GirFunction[];
-    enumerations: GirEnumeration[];
-    bitfields: GirEnumeration[];
-    records: GirRecord[];
-    callbacks: GirCallback[];
-    constants: GirConstant[];
-    doc?: string;
-};
-/**
- * A constant value defined in a GIR namespace.
+ * All type references use fully qualified names (Namespace.TypeName)
+ * except for intrinsic types which remain unqualified.
  */
-export type GirConstant = {
-    name: string;
-    cType: string;
-    value: string;
-    type: GirType;
-    doc?: string;
-};
 /**
- * A callback type definition (function pointer type).
+ * A fully qualified type name.
+ * Always in the format "Namespace.TypeName" (e.g., "Gtk.Widget", "GLib.Variant").
+ * Intrinsic types like "gint" are NOT QualifiedNames.
  */
-export type GirCallback = {
-    name: string;
-    cType: string;
-    returnType: GirType;
-    parameters: GirParameter[];
-    doc?: string;
+export type QualifiedName = string & {
+    readonly __brand: "QualifiedName";
 };
 /**
- * A GObject interface definition.
- *
- * Interfaces in GObject are similar to TypeScript interfaces - they
- * define a contract that classes can implement.
+ * Creates a QualifiedName from namespace and type name.
  */
-export type GirInterface = {
-    name: string;
-    cType: string;
-    glibTypeName?: string;
-    prerequisites: string[];
-    methods: GirMethod[];
-    properties: GirProperty[];
-    signals: GirSignal[];
-    doc?: string;
-};
-/**
- * A GObject class definition.
- *
- * Classes are the primary building blocks of GObject-based libraries
- * like GTK. They support single inheritance, interface implementation,
- * properties, signals, and methods.
- */
-export type GirClass = {
-    name: string;
-    cType: string;
-    parent?: string;
-    abstract?: boolean;
-    glibTypeName?: string;
-    glibGetType?: string;
-    cSymbolPrefix?: string;
-    implements: string[];
-    methods: GirMethod[];
-    constructors: GirConstructor[];
-    functions: GirFunction[];
-    properties: GirProperty[];
-    signals: GirSignal[];
-    doc?: string;
-};
-/**
- * A GLib record (boxed type or struct).
- *
- * Records are value types that can be allocated on the stack or heap.
- * They may have fields, methods, and constructors but no inheritance.
- */
-export type GirRecord = {
-    name: string;
-    cType: string;
-    opaque?: boolean;
-    disguised?: boolean;
-    glibTypeName?: string;
-    glibGetType?: string;
-    fields: GirField[];
-    methods: GirMethod[];
-    constructors: GirConstructor[];
-    functions: GirFunction[];
-    doc?: string;
-};
+export declare const qualifiedName: (namespace: string, name: string) => QualifiedName;
 /**
- * A field within a record or class.
+ * Parses a QualifiedName into its parts.
  */
-export type GirField = {
+export declare const parseQualifiedName: (qn: QualifiedName) => {
+    namespace: string;
     name: string;
-    type: GirType;
-    writable?: boolean;
-    readable?: boolean;
-    private?: boolean;
-    doc?: string;
 };
 /**
- * A method on a class, interface, or record.
+ * The kind of a user-defined type (not intrinsic).
  */
-export type GirMethod = {
-    name: string;
-    cIdentifier: string;
-    returnType: GirType;
-    parameters: GirParameter[];
-    throws?: boolean;
-    doc?: string;
-    returnDoc?: string;
-};
+export type TypeKind = "class" | "interface" | "record" | "enum" | "flags" | "callback";
 /**
- * A constructor for a class or record.
+ * Container type discriminator for generic GLib containers.
  */
-export type GirConstructor = {
-    name: string;
-    cIdentifier: string;
-    returnType: GirType;
-    parameters: GirParameter[];
-    throws?: boolean;
-    doc?: string;
-    returnDoc?: string;
+export type ContainerType = "ghashtable" | "gptrarray" | "garray" | "glist" | "gslist";
+type RepositoryLike = {
+    resolveClass(name: QualifiedName): GirClass | null;
+    resolveInterface(name: QualifiedName): GirInterface | null;
+    resolveRecord(name: QualifiedName): GirRecord | null;
+    resolveEnum(name: QualifiedName): GirEnumeration | null;
+    resolveFlags(name: QualifiedName): GirEnumeration | null;
+    resolveCallback(name: QualifiedName): GirCallback | null;
+    getTypeKind(name: QualifiedName): TypeKind | null;
+    findClasses(predicate: (cls: GirClass) => boolean): GirClass[];
 };
 /**
- * A standalone function or static method.
+ * Normalized namespace containing all resolved types.
  */
-export type GirFunction = {
-    name: string;
-    cIdentifier: string;
-    returnType: GirType;
-    parameters: GirParameter[];
-    throws?: boolean;
-    doc?: string;
-    returnDoc?: string;
-};
+export declare class GirNamespace {
+    readonly name: string;
+    readonly version: string;
+    readonly sharedLibrary: string;
+    readonly cPrefix: string;
+    readonly classes: Map<string, GirClass>;
+    readonly interfaces: Map<string, GirInterface>;
+    readonly records: Map<string, GirRecord>;
+    readonly enumerations: Map<string, GirEnumeration>;
+    readonly bitfields: Map<string, GirEnumeration>;
+    readonly callbacks: Map<string, GirCallback>;
+    readonly functions: Map<string, GirFunction>;
+    readonly constants: Map<string, GirConstant>;
+    readonly doc?: string;
+    constructor(data: {
+        name: string;
+        version: string;
+        sharedLibrary: string;
+        cPrefix: string;
+        classes: Map<string, GirClass>;
+        interfaces: Map<string, GirInterface>;
+        records: Map<string, GirRecord>;
+        enumerations: Map<string, GirEnumeration>;
+        bitfields: Map<string, GirEnumeration>;
+        callbacks: Map<string, GirCallback>;
+        functions: Map<string, GirFunction>;
+        constants: Map<string, GirConstant>;
+        doc?: string;
+    });
+}
 /**
- * A parameter to a function, method, or callback.
- *
- * Includes direction (in/out/inout) and ownership transfer information
- * for proper memory management in generated bindings.
+ * Normalized class with helper methods.
  */
-export type GirParameter = {
-    name: string;
-    type: GirType;
-    direction?: "in" | "out" | "inout";
-    callerAllocates?: boolean;
-    nullable?: boolean;
-    optional?: boolean;
-    scope?: "async" | "call" | "notified";
-    closure?: number;
-    destroy?: number;
-    transferOwnership?: "none" | "full" | "container";
-    doc?: string;
-};
+export declare class GirClass {
+    readonly name: string;
+    readonly qualifiedName: QualifiedName;
+    readonly cType: string;
+    readonly parent: QualifiedName | null;
+    readonly abstract: boolean;
+    readonly glibTypeName?: string;
+    readonly glibGetType?: string;
+    readonly cSymbolPrefix?: string;
+    readonly implements: QualifiedName[];
+    readonly methods: GirMethod[];
+    readonly constructors: GirConstructor[];
+    readonly staticFunctions: GirFunction[];
+    readonly properties: GirProperty[];
+    readonly signals: GirSignal[];
+    readonly doc?: string;
+    /** @internal */
+    private _repo?;
+    constructor(data: {
+        name: string;
+        qualifiedName: QualifiedName;
+        cType: string;
+        parent: QualifiedName | null;
+        abstract: boolean;
+        glibTypeName?: string;
+        glibGetType?: string;
+        cSymbolPrefix?: string;
+        implements: QualifiedName[];
+        methods: GirMethod[];
+        constructors: GirConstructor[];
+        staticFunctions: GirFunction[];
+        properties: GirProperty[];
+        signals: GirSignal[];
+        doc?: string;
+    });
+    /** @internal */
+    _setRepository(repo: RepositoryLike): void;
+    /** Checks if this class is a subclass of another (direct or transitive). */
+    isSubclassOf(qualifiedName: QualifiedName): boolean;
+    /** Gets the full inheritance chain from this class to the root. */
+    getInheritanceChain(): QualifiedName[];
+    /** Gets the parent class object, or null if this is a root class. */
+    getParent(): GirClass | null;
+    /** Checks if this class directly or transitively implements an interface. */
+    implementsInterface(qualifiedName: QualifiedName): boolean;
+    /** Gets all implemented interfaces including inherited ones. */
+    getAllImplementedInterfaces(): QualifiedName[];
+    /** Finds a method defined on this class by name. */
+    getMethod(name: string): GirMethod | null;
+    /** Finds a property defined on this class by name. */
+    getProperty(name: string): GirProperty | null;
+    /** Finds a signal defined on this class by name. */
+    getSignal(name: string): GirSignal | null;
+    /** Finds a constructor by name. */
+    getConstructor(name: string): GirConstructor | null;
+    /** Gets all methods including inherited ones. */
+    getAllMethods(): GirMethod[];
+    /** Gets all properties including inherited ones. */
+    getAllProperties(): GirProperty[];
+    /** Gets all signals including inherited ones. */
+    getAllSignals(): GirSignal[];
+    /** Finds a method by name, searching up the inheritance chain. */
+    findMethod(name: string): GirMethod | null;
+    /** Finds a property by name, searching up the inheritance chain. */
+    findProperty(name: string): GirProperty | null;
+    /** Finds a signal by name, searching up the inheritance chain. */
+    findSignal(name: string): GirSignal | null;
+    /** True if this is an abstract class. */
+    isAbstract(): boolean;
+    /** True if this has a GType (most GObject classes do). */
+    hasGType(): boolean;
+    /** Gets direct subclasses of this class. */
+    getDirectSubclasses(): GirClass[];
+}
 /**
- * A type reference in GIR.
- *
- * Can represent primitive types, objects, arrays, or boxed types.
- * Includes C type information and ownership semantics.
+ * Normalized interface with helper methods.
  */
-export type GirType = {
-    name: string;
-    cType?: string;
-    isArray?: boolean;
-    elementType?: GirType;
-    transferOwnership?: "none" | "full" | "container";
-    nullable?: boolean;
-};
+export declare class GirInterface {
+    readonly name: string;
+    readonly qualifiedName: QualifiedName;
+    readonly cType: string;
+    readonly glibTypeName?: string;
+    readonly prerequisites: QualifiedName[];
+    readonly methods: GirMethod[];
+    readonly properties: GirProperty[];
+    readonly signals: GirSignal[];
+    readonly doc?: string;
+    /** @internal */
+    private _repo?;
+    constructor(data: {
+        name: string;
+        qualifiedName: QualifiedName;
+        cType: string;
+        glibTypeName?: string;
+        prerequisites: QualifiedName[];
+        methods: GirMethod[];
+        properties: GirProperty[];
+        signals: GirSignal[];
+        doc?: string;
+    });
+    /** @internal */
+    _setRepository(repo: RepositoryLike): void;
+    /** Checks if this interface has a prerequisite (direct or transitive). */
+    hasPrerequisite(qualifiedName: QualifiedName): boolean;
+    /** Gets all prerequisites including transitive ones. */
+    getAllPrerequisites(): QualifiedName[];
+    /** Finds a method by name. */
+    getMethod(name: string): GirMethod | null;
+    /** Finds a property by name. */
+    getProperty(name: string): GirProperty | null;
+    /** Finds a signal by name. */
+    getSignal(name: string): GirSignal | null;
+}
 /**
- * A GObject property definition.
- *
- * Properties in GObject are observable values with getter/setter
- * methods and change notification support.
+ * Normalized record (boxed type or plain struct) with helper methods.
  */
-export type GirProperty = {
-    name: string;
-    type: GirType;
-    readable?: boolean;
-    writable?: boolean;
-    constructOnly?: boolean;
-    hasDefault?: boolean;
-    getter?: string;
-    setter?: string;
-    doc?: string;
-};
+export declare class GirRecord {
+    readonly name: string;
+    readonly qualifiedName: QualifiedName;
+    readonly cType: string;
+    readonly opaque: boolean;
+    readonly disguised: boolean;
+    readonly glibTypeName?: string;
+    readonly glibGetType?: string;
+    readonly isGtypeStructFor?: string;
+    readonly fields: GirField[];
+    readonly methods: GirMethod[];
+    readonly constructors: GirConstructor[];
+    readonly staticFunctions: GirFunction[];
+    readonly doc?: string;
+    constructor(data: {
+        name: string;
+        qualifiedName: QualifiedName;
+        cType: string;
+        opaque: boolean;
+        disguised: boolean;
+        glibTypeName?: string;
+        glibGetType?: string;
+        isGtypeStructFor?: string;
+        fields: GirField[];
+        methods: GirMethod[];
+        constructors: GirConstructor[];
+        staticFunctions: GirFunction[];
+        doc?: string;
+    });
+    /** True if this is a GLib boxed type (has glibTypeName). */
+    isBoxed(): boolean;
+    /** True if this is a GType struct (vtable for a class/interface). */
+    isGtypeStruct(): boolean;
+    /** True if this is a plain C struct (no GType, has public fields). */
+    isPlainStruct(): boolean;
+    /** Gets public (non-private) fields only. */
+    getPublicFields(): GirField[];
+    /** Finds a method by name. */
+    getMethod(name: string): GirMethod | null;
+    /** Finds a field by name. */
+    getField(name: string): GirField | null;
+    /** Finds a constructor by name. */
+    getConstructor(name: string): GirConstructor | null;
+}
 /**
- * A GObject signal definition.
- *
- * Signals are the GObject event system, allowing objects to emit
- * notifications that handlers can connect to.
+ * Normalized enumeration with helper methods.
  */
-export type GirSignal = {
-    name: string;
-    when?: "first" | "last" | "cleanup";
-    returnType?: GirType;
-    parameters?: GirParameter[];
-    doc?: string;
-};
+export declare class GirEnumeration {
+    readonly name: string;
+    readonly qualifiedName: QualifiedName;
+    readonly cType: string;
+    readonly members: GirEnumerationMember[];
+    readonly doc?: string;
+    constructor(data: {
+        name: string;
+        qualifiedName: QualifiedName;
+        cType: string;
+        members: GirEnumerationMember[];
+        doc?: string;
+    });
+    /** Finds a member by name. */
+    getMember(name: string): GirEnumerationMember | null;
+    /** Finds a member by value. */
+    getMemberByValue(value: string): GirEnumerationMember | null;
+    /** Gets all member names. */
+    getMemberNames(): string[];
+}
 /**
- * An enumeration or bitfield definition.
+ * Normalized enumeration member.
  */
-export type GirEnumeration = {
-    name: string;
-    cType: string;
-    members: GirEnumerationMember[];
-    doc?: string;
-};
+export declare class GirEnumerationMember {
+    readonly name: string;
+    readonly value: string;
+    readonly cIdentifier: string;
+    readonly doc?: string;
+    constructor(data: {
+        name: string;
+        value: string;
+        cIdentifier: string;
+        doc?: string;
+    });
+}
 /**
- * A member of an enumeration or bitfield.
+ * Normalized callback type.
  */
-export type GirEnumerationMember = {
-    name: string;
-    value: string;
-    cIdentifier: string;
-    doc?: string;
-};
+export declare class GirCallback {
+    readonly name: string;
+    readonly qualifiedName: QualifiedName;
+    readonly cType: string;
+    readonly returnType: GirType;
+    readonly parameters: GirParameter[];
+    readonly doc?: string;
+    constructor(data: {
+        name: string;
+        qualifiedName: QualifiedName;
+        cType: string;
+        returnType: GirType;
+        parameters: GirParameter[];
+        doc?: string;
+    });
+}
 /**
- * Describes how a type should be marshalled for FFI calls.
- *
- * Used by the code generator to create proper FFI type descriptors
- * for the native module.
+ * Normalized constant.
  */
-export type FfiTypeDescriptor = {
-    /**
-     * The FFI type: "int", "float", "string", "boolean", "boxed", "struct", "gobject", etc.
-     */
-    type: string;
-    /**
-     * Size in bits for numeric types, or bytes for struct types.
-     */
-    size?: number;
-    unsigned?: boolean;
-    borrowed?: boolean;
-    innerType?: FfiTypeDescriptor | string;
-    lib?: string;
-    getTypeFn?: string;
-    itemType?: FfiTypeDescriptor;
-    listType?: "glist" | "gslist";
-    trampoline?: "asyncReady" | "destroy" | "drawFunc" | "scaleFormatValueFunc" | "shortcutFunc" | "treeListModelCreateFunc";
-    sourceType?: FfiTypeDescriptor;
-    resultType?: FfiTypeDescriptor;
-    argTypes?: FfiTypeDescriptor[];
-    returnType?: FfiTypeDescriptor;
-    optional?: boolean;
-};
+export declare class GirConstant {
+    readonly name: string;
+    readonly qualifiedName: QualifiedName;
+    readonly cType: string;
+    readonly value: string;
+    readonly type: GirType;
+    readonly doc?: string;
+    constructor(data: {
+        name: string;
+        qualifiedName: QualifiedName;
+        cType: string;
+        value: string;
+        type: GirType;
+        doc?: string;
+    });
+}
 /**
- * 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
+ * Normalized method with helper methods.
  */
-export declare const buildClassMap: (classes: GirClass[]) => Map<string, GirClass>;
+export declare class GirMethod {
+    readonly name: string;
+    readonly cIdentifier: string;
+    readonly returnType: GirType;
+    readonly parameters: GirParameter[];
+    readonly throws: boolean;
+    readonly doc?: string;
+    readonly returnDoc?: string;
+    /** For async methods, the name of the corresponding finish function */
+    readonly finishFunc?: string;
+    constructor(data: {
+        name: string;
+        cIdentifier: string;
+        returnType: GirType;
+        parameters: GirParameter[];
+        throws: boolean;
+        doc?: string;
+        returnDoc?: string;
+        finishFunc?: string;
+    });
+    /** True if this follows the async/finish pattern. */
+    isAsync(): boolean;
+    /** True if this is a _finish method for an async operation. */
+    isAsyncFinish(): boolean;
+    /** Gets the corresponding _finish method name if this is async. */
+    getFinishMethodName(): string | null;
+    /** Gets required (non-optional, non-nullable) parameters. */
+    getRequiredParameters(): GirParameter[];
+    /** Gets optional parameters. */
+    getOptionalParameters(): GirParameter[];
+    /** True if any parameter is an out parameter. */
+    hasOutParameters(): boolean;
+    /** Gets out parameters only. */
+    getOutParameters(): GirParameter[];
+}
 /**
- * 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
+ * Normalized constructor.
  */
-export declare const registerEnumsFromNamespace: (typeMapper: TypeMapper, namespace: GirNamespace) => void;
+export declare class GirConstructor {
+    readonly name: string;
+    readonly cIdentifier: string;
+    readonly returnType: GirType;
+    readonly parameters: GirParameter[];
+    readonly throws: boolean;
+    readonly doc?: string;
+    readonly returnDoc?: string;
+    constructor(data: {
+        name: string;
+        cIdentifier: string;
+        returnType: GirType;
+        parameters: GirParameter[];
+        throws: boolean;
+        doc?: string;
+        returnDoc?: string;
+    });
+    /** Gets required (non-optional, non-nullable) parameters. */
+    getRequiredParameters(): GirParameter[];
+}
 /**
- * The kind of a registered type.
+ * Normalized standalone function.
  */
-export type TypeKind = "class" | "interface" | "enum" | "flags" | "record" | "callback";
+export declare class GirFunction {
+    readonly name: string;
+    readonly cIdentifier: string;
+    readonly returnType: GirType;
+    readonly parameters: GirParameter[];
+    readonly throws: boolean;
+    readonly doc?: string;
+    readonly returnDoc?: string;
+    constructor(data: {
+        name: string;
+        cIdentifier: string;
+        returnType: GirType;
+        parameters: GirParameter[];
+        throws: boolean;
+        doc?: string;
+        returnDoc?: string;
+    });
+    /** True if this follows the async/finish pattern. */
+    isAsync(): boolean;
+    /** Gets required parameters. */
+    getRequiredParameters(): GirParameter[];
+}
 /**
- * A type registered in the type registry.
- *
- * Contains metadata about the type including its namespace,
- * original name, and transformed TypeScript name.
+ * Normalized parameter with helper methods.
  */
-export type RegisteredType = {
-    kind: TypeKind;
-    name: string;
-    namespace: string;
-    transformedName: string;
-    glibTypeName?: string;
-    sharedLibrary?: string;
-    glibGetType?: string;
-    /**
-     * If true, this is a plain C struct without GType registration.
-     * These require different FFI handling than boxed types.
-     */
-    isPlainStruct?: boolean;
-    /**
-     * Size in bytes for plain structs (for allocation).
-     */
-    structSize?: number;
-    /**
-     * Field definitions for plain structs.
-     */
-    structFields?: Array<{
+export declare class GirParameter {
+    readonly name: string;
+    readonly type: GirType;
+    readonly direction: "in" | "out" | "inout";
+    readonly callerAllocates: boolean;
+    readonly nullable: boolean;
+    readonly optional: boolean;
+    readonly scope?: "async" | "call" | "notified";
+    readonly closure?: number;
+    readonly destroy?: number;
+    readonly transferOwnership?: "none" | "full" | "container";
+    readonly doc?: string;
+    constructor(data: {
         name: string;
-        offset: number;
-        type: string;
-    }>;
-};
+        type: GirType;
+        direction: "in" | "out" | "inout";
+        callerAllocates: boolean;
+        nullable: boolean;
+        optional: boolean;
+        scope?: "async" | "call" | "notified";
+        closure?: number;
+        destroy?: number;
+        transferOwnership?: "none" | "full" | "container";
+        doc?: string;
+    });
+    /** True if this is an input parameter. */
+    isIn(): boolean;
+    /** True if this is an output parameter. */
+    isOut(): boolean;
+    /** True if this is a callback parameter (has scope). */
+    isCallback(): boolean;
+    /** True if this is the user_data for a callback. */
+    isClosureData(): boolean;
+    /** True if this is a destroy notify for a callback. */
+    isDestroyNotify(): boolean;
+    /** True if caller must allocate memory for this out param. */
+    requiresCallerAllocation(): boolean;
+}
 /**
- * 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 property with helper methods.
  */
-export declare class TypeRegistry {
-    private types;
-    /**
-     * Registers a native class type.
-     *
-     * @param namespace - The GIR namespace (e.g., "Gtk")
-     * @param name - The class name (e.g., "Button")
-     */
-    registerNativeClass(namespace: string, name: string): void;
-    /**
-     * Registers an interface type.
-     *
-     * @param namespace - The GIR namespace
-     * @param name - The interface name
-     */
-    registerInterface(namespace: string, name: string): void;
-    /**
-     * Registers an enumeration type.
-     *
-     * @param namespace - The GIR namespace
-     * @param name - The enum name
-     */
-    registerEnum(namespace: string, name: string): void;
-    /**
-     * Registers a flags (bitfield) type.
-     *
-     * @param namespace - The GIR namespace
-     * @param name - The flags name
-     */
-    registerFlags(namespace: string, name: string): void;
-    /**
-     * 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: string, name: string, glibTypeName?: string, sharedLibrary?: string, glibGetType?: string, isPlainStruct?: boolean, structSize?: number, structFields?: Array<{
+export declare class GirProperty {
+    readonly name: string;
+    readonly type: GirType;
+    readonly readable: boolean;
+    readonly writable: boolean;
+    readonly constructOnly: boolean;
+    readonly hasDefault: boolean;
+    readonly getter?: string;
+    readonly setter?: string;
+    readonly doc?: string;
+    constructor(data: {
         name: string;
-        offset: number;
-        type: string;
-    }>): void;
-    /**
-     * Registers a callback type.
-     *
-     * @param namespace - The GIR namespace
-     * @param name - The callback name
-     */
-    registerCallback(namespace: string, name: string): void;
-    /**
-     * 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: string): RegisteredType | undefined;
-    /**
-     * 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: string, currentNamespace: string): RegisteredType | undefined;
-    /**
-     * 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: GirNamespace[]): TypeRegistry;
+        type: GirType;
+        readable: boolean;
+        writable: boolean;
+        constructOnly: boolean;
+        hasDefault: boolean;
+        getter?: string;
+        setter?: string;
+        doc?: string;
+    });
+    /** True if readable but not writable. */
+    isReadOnly(): boolean;
+    /** True if writable but not readable. */
+    isWriteOnly(): boolean;
+    /** True if can only be set during construction. */
+    isConstructOnly(): boolean;
+    /** True if has both getter and setter methods. */
+    hasAccessors(): boolean;
 }
 /**
- * Describes usage of a type from another namespace.
- *
- * Used to track import dependencies during code generation.
+ * Normalized signal with helper methods.
  */
-export type ExternalTypeUsage = {
-    namespace: string;
-    name: string;
-    transformedName: string;
-    kind: TypeKind;
-};
+export declare class GirSignal {
+    readonly name: string;
+    readonly when: "first" | "last" | "cleanup";
+    readonly returnType: GirType | null;
+    readonly parameters: GirParameter[];
+    readonly doc?: string;
+    constructor(data: {
+        name: string;
+        when: "first" | "last" | "cleanup";
+        returnType: GirType | null;
+        parameters: GirParameter[];
+        doc?: string;
+    });
+    /** True if the signal returns a value. */
+    hasReturnValue(): boolean;
+}
 /**
- * Result of mapping a GIR type to TypeScript and FFI representations.
+ * Normalized field.
  */
-export type MappedType = {
-    ts: string;
-    ffi: FfiTypeDescriptor;
-    externalType?: ExternalTypeUsage;
-    kind?: TypeKind;
-    nullable?: boolean;
-};
+export declare class GirField {
+    readonly name: string;
+    readonly type: GirType;
+    readonly writable: boolean;
+    readonly readable: boolean;
+    readonly private: boolean;
+    readonly doc?: string;
+    constructor(data: {
+        name: string;
+        type: GirType;
+        writable: boolean;
+        readable: boolean;
+        private: boolean;
+        doc?: string;
+    });
+}
 /**
- * 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 type reference with helper methods.
  */
-export declare class TypeMapper {
-    private enumNames;
-    private enumTransforms;
-    private flagsNames;
-    private flagsTransforms;
-    private recordNames;
-    private recordTransforms;
-    private recordGlibTypes;
-    private skippedClasses;
-    private onEnumUsed?;
-    private onRecordUsed?;
-    private onExternalTypeUsed?;
-    private onSameNamespaceClassUsed?;
-    private typeRegistry?;
-    private currentNamespace?;
-    private forceExternalNamespace?;
-    /**
-     * Registers an enumeration for type mapping.
-     *
-     * @param originalName - The GIR enum name
-     * @param transformedName - Optional transformed TypeScript name
-     */
-    registerEnum(originalName: string, transformedName?: string): void;
-    /**
-     * Registers a flags (bitfield) type for type mapping.
-     *
-     * @param originalName - The GIR flags name
-     * @param transformedName - Optional transformed TypeScript name
-     */
-    registerFlags(originalName: string, transformedName?: string): void;
-    /**
-     * 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: string, transformedName?: string, glibTypeName?: string): void;
-    setEnumUsageCallback(callback: ((enumName: string) => void) | null): void;
-    getEnumUsageCallback(): ((enumName: string) => void) | null;
-    setRecordUsageCallback(callback: ((recordName: string) => void) | null): void;
-    getRecordUsageCallback(): ((recordName: string) => void) | null;
-    setExternalTypeUsageCallback(callback: ((usage: ExternalTypeUsage) => void) | null): void;
-    getExternalTypeUsageCallback(): ((usage: ExternalTypeUsage) => void) | null;
-    setSameNamespaceClassUsageCallback(callback: ((className: string, originalName: string) => void) | null): void;
-    getSameNamespaceClassUsageCallback(): ((className: string, originalName: string) => void) | 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: TypeRegistry, currentNamespace: string): void;
-    setForceExternalNamespace(namespace: string | null): void;
-    registerSkippedClass(name: string): void;
-    clearSkippedClasses(): void;
-    /**
-     * 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: GirType, isReturn?: boolean, parentTransferOwnership?: string): MappedType;
-    isCallback(typeName: string): boolean;
-    /**
-     * 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: GirParameter): MappedType;
-    isClosureTarget(paramIndex: number, allParams: GirParameter[]): boolean;
-    isNullable(param: GirParameter): boolean;
-    hasUnsupportedCallback(param: GirParameter): boolean;
+export declare class GirType {
+    /** Type name - either a QualifiedName or an intrinsic type string */
+    readonly name: QualifiedName | string;
+    readonly cType?: string;
+    readonly isArray: boolean;
+    readonly elementType: GirType | null;
+    readonly typeParameters: readonly GirType[];
+    readonly containerType?: ContainerType;
+    readonly transferOwnership?: "none" | "full" | "container";
+    readonly nullable: boolean;
+    constructor(data: {
+        name: QualifiedName | string;
+        cType?: string;
+        isArray: boolean;
+        elementType: GirType | null;
+        typeParameters?: readonly GirType[];
+        containerType?: ContainerType;
+        transferOwnership?: "none" | "full" | "container";
+        nullable: boolean;
+    });
+    /** True if this is an intrinsic/primitive type. */
+    isIntrinsic(): boolean;
+    /** True if this is a string type (utf8 or filename). */
+    isString(): boolean;
+    /** True if this is a numeric type. */
+    isNumeric(): boolean;
+    /** True if this is a boolean type. */
+    isBoolean(): boolean;
+    /** True if this is void. */
+    isVoid(): boolean;
+    /** True if this is GVariant. */
+    isVariant(): boolean;
+    /** True if this is GParamSpec. */
+    isParamSpec(): boolean;
+    /** True if this is a GHashTable container. */
+    isHashTable(): boolean;
+    /** True if this is a GPtrArray container. */
+    isPtrArray(): boolean;
+    /** True if this is a GArray container. */
+    isGArray(): boolean;
+    /** True if this is a GList or GSList container. */
+    isList(): boolean;
+    /** True if this is any generic container type. */
+    isGenericContainer(): boolean;
+    /** Gets the key type for GHashTable, or null for other types. */
+    getKeyType(): GirType | null;
+    /** Gets the value type for GHashTable, or null for other types. */
+    getValueType(): GirType | null;
+    /** Gets the namespace part of a qualified name, or null for intrinsics. */
+    getNamespace(): string | null;
+    /** Gets the simple name part (without namespace). */
+    getSimpleName(): string;
 }
+export {};