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

package/lib/types/gir-doc-element.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gir-doc-element.js","sourceRoot":"","sources":["../../src/types/gir-doc-element.ts"],"names":[],"mappings":""}

package/lib/types/gir-enum-element.d.ts

@@ -0,0 +1,19 @@
+import type { GirFunctionElement, GirMemberElement, GirInfoAttrs, GirInfoElements, PartOfModule, TsEnum } from './index.js';
+export interface GirEnumElement extends PartOfModule, GirInfoElements {
+    /** element defining a enumeration type similar to enum in C/C++ */
+    $: GirInfoAttrs & {
+        /** name of the enumeration */
+        name: string;
+        /** corresponding C type of the enumeration type */
+        'c:type': string;
+        /** GObject compatible type name */
+        'glib:type-name'?: string;
+        /** function to retrieve the GObject compatible type of the element */
+        'glib:get-type'?: string;
+        /** Error domain of this enumeration in a stringified form */
+        'glib:error-domain'?: string;
+    };
+    member?: GirMemberElement[];
+    function?: GirFunctionElement[];
+    _tsData?: TsEnum;
+}

package/lib/types/gir-enum-element.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gir-enum-element.js.map

package/lib/types/gir-enum-element.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gir-enum-element.js","sourceRoot":"","sources":["../../src/types/gir-enum-element.ts"],"names":[],"mappings":""}

package/lib/types/gir-field-element.d.ts

@@ -0,0 +1,18 @@
+import { GirInfoElements, GirAnyType, GirInfoAttrs, GirBoolean, GirUnparsedNumber, GirCallbackElement, PartOfClass, TsVar } from './index.js';
+export interface GirFieldElement extends PartOfClass, GirInfoElements, GirAnyType {
+    /** A field of struct of union structure, that is a C bit field, that is a fixed length in bits variable */
+    $: GirInfoAttrs & {
+        /** name of the field */
+        name: string;
+        /** Binary attribute, true if the field is writeable */
+        writable?: GirBoolean;
+        /** Binary attribute, true if the field is readable */
+        readable?: GirBoolean;
+        /** Binary attribute, true if the field is private to the structure or has public ("0") visibility */
+        private?: GirBoolean;
+        /** number of bits of the field */
+        bits?: GirUnparsedNumber; /** integer */
+    };
+    callback?: GirCallbackElement[];
+    _tsData?: TsVar;
+}

package/lib/types/gir-field-element.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gir-field-element.js.map

package/lib/types/gir-field-element.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gir-field-element.js","sourceRoot":"","sources":["../../src/types/gir-field-element.ts"],"names":[],"mappings":""}

package/lib/types/gir-function-element.d.ts

@@ -0,0 +1,8 @@
+import type { GirCallableAttrs, GirInfoAttrs, GirDocElement, PartOfClass, GirCallableParams, GirCallableReturn, TsMethod } from './index.js';
+export interface GirFunctionElement extends PartOfClass, GirDocElement {
+    /** element defining a standalone function (as usual in most programming languages) */
+    $: GirInfoAttrs & GirCallableAttrs;
+    parameters?: [GirCallableParams];
+    'return-value'?: GirCallableReturn[];
+    _tsData?: TsMethod;
+}

package/lib/types/gir-function-element.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gir-function-element.js.map

package/lib/types/gir-function-element.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gir-function-element.js","sourceRoot":"","sources":["../../src/types/gir-function-element.ts"],"names":[],"mappings":""}

package/lib/types/gir-implements.d.ts

@@ -0,0 +1,8 @@
+import { GirInfoAttrs } from './index.js';
+export interface GirImplements {
+    /** Give the name of the interface it implements. This element is generally used within a class element */
+    $: GirInfoAttrs & {
+        /** name of the interface implemented by a class */
+        name: string;
+    };
+}

package/lib/types/gir-implements.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gir-implements.js.map

package/lib/types/gir-implements.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gir-implements.js","sourceRoot":"","sources":["../../src/types/gir-implements.ts"],"names":[],"mappings":""}

package/lib/types/gir-include.d.ts

@@ -0,0 +1,9 @@
+export interface GirInclude {
+    /** Dependant namespace to include with the current namespace. For example, Gtk will need the namespace GLib */
+    $: {
+        /** name of the dependant namespace to include */
+        name: string;
+        /** version of the dependant namespace to use */
+        version?: string;
+    };
+}

package/lib/types/gir-include.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gir-include.js.map

package/lib/types/gir-include.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gir-include.js","sourceRoot":"","sources":["../../src/types/gir-include.ts"],"names":[],"mappings":""}

package/lib/types/gir-info-attrs.d.ts

@@ -0,0 +1,13 @@
+import { GirBoolean } from './gir-boolean';
+export interface GirInfoAttrs {
+    /** Binary attribute which is GirBoolean(false) if the element is not introspectable. It doesn't exist in the bindings, due in general to missing information in the annotations in the original C code */
+    introspectable?: GirBoolean;
+    /** Binary attribute which isBinaryOption (true) if the element has been deprecated */
+    deprecated?: string;
+    /** Version number from which this element is deprecated */
+    'deprecated-version'?: string;
+    /** version number of an element */
+    version?: string;
+    /** give the statibility status of the element. Can take the values "Stable", "Unstable" or "Private" */
+    stability?: string[];
+}

package/lib/types/gir-info-attrs.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gir-info-attrs.js.map

package/lib/types/gir-info-attrs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gir-info-attrs.js","sourceRoot":"","sources":["../../src/types/gir-info-attrs.ts"],"names":[],"mappings":""}

package/lib/types/gir-info-elements.d.ts

@@ -0,0 +1,5 @@
+import { GirAnnotation } from './gir-annotation';
+import { GirDocElement } from './gir-doc-element';
+export interface GirInfoElements extends GirDocElement {
+    annotation: GirAnnotation[];
+}

package/lib/types/gir-info-elements.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gir-info-elements.js.map

package/lib/types/gir-info-elements.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gir-info-elements.js","sourceRoot":"","sources":["../../src/types/gir-info-elements.ts"],"names":[],"mappings":""}

package/lib/types/gir-instance-parameter.d.ts

@@ -0,0 +1,21 @@
+import { GirBoolean, GirAnyType, GirTransferOwnership, GirDirection, GirType, TsInstanceParameter } from './index.js';
+/**
+ * instance-parameter is a parameter of a C function which is an instance of an existing object.
+ * So the callable is surely a method of a class, and this parameter points to the instance of the object.
+ * In C++, this would be equivalent to the pointer this which is not passed to the method, in Python it's equivalent to self.
+ **/
+export interface GirInstanceParameter extends GirAnyType {
+    $: Partial<{
+        /** name of the instance-parameter */ name: string;
+        /** Binary attribute, true if the parameter can have a null value */
+        nullable?: GirBoolean;
+        /** @deprecated Replaced by nullable and optional */
+        'allow-none'?: GirBoolean;
+        /** direction of the parameter. "in" goes into the callable, "out" for output parameters from the callable (reference in C++, var in Pascal, etc...), "inout" for both (like a pre-allocated structure which will be filled-in by the callable) */
+        direction?: GirDirection;
+        /** Binary attribute, true if the caller should allocate the parameter before calling the callable */
+        'caller-allocates'?: GirBoolean;
+    }> & Partial<GirTransferOwnership>;
+    type?: GirType[];
+    _tsData?: TsInstanceParameter;
+}

package/lib/types/gir-instance-parameter.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gir-instance-parameter.js.map

package/lib/types/gir-instance-parameter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gir-instance-parameter.js","sourceRoot":"","sources":["../../src/types/gir-instance-parameter.ts"],"names":[],"mappings":""}

package/lib/types/gir-interface-element.d.ts

@@ -0,0 +1,31 @@
+import { GirInfoElements, GirPrerequisite, GirImplements, GirConstructorElement, GirMethodElement, GirVirtualMethodElement, GirFunctionElement, GirFieldElement, GirPropertyElement, GirCallbackElement, GirConstantElement, GirSignalElement, PartOfModule, TsClass } from './index.js';
+export interface GirInterfaceElement extends PartOfModule, GirInfoElements {
+    /** Abstract interface to other classes */
+    $: {
+        /** name of the interface */
+        name: string;
+        /** Type name compatible with the GObject type system */
+        'glib:type-name': string;
+        /** Function to get the GObject compatible type of the interface  */
+        'glib:get-type': string;
+        /** prefix to filter out from C functions. For example, gtk_window_new will lose gtk_ */
+        'c:symbol-prefix'?: string;
+        /** Corresponding C type */
+        'c:type'?: string;
+        /** GObject compatible C structure defining the Interface */
+        'glib:type-struct'?: string;
+    };
+    prerequisite?: GirPrerequisite[];
+    implements?: GirImplements[];
+    function?: GirFunctionElement[];
+    constructors?: GirConstructorElement[];
+    method?: GirMethodElement[];
+    'virtual-method'?: GirVirtualMethodElement[];
+    field?: GirFieldElement[];
+    property?: GirPropertyElement[];
+    signal?: GirSignalElement[];
+    'glib:signal'?: GirSignalElement[];
+    callback?: GirCallbackElement[];
+    constant?: GirConstantElement[];
+    _tsData?: TsClass;
+}

package/lib/types/gir-interface-element.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gir-interface-element.js.map

package/lib/types/gir-interface-element.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gir-interface-element.js","sourceRoot":"","sources":["../../src/types/gir-interface-element.ts"],"names":[],"mappings":""}

package/lib/types/gir-member-element.d.ts

@@ -0,0 +1,17 @@
+import { GirInfoElements, GirInfoAttrs, TsMember } from './index.js';
+export interface GirMemberElement extends GirInfoElements {
+    /** element defining a member of a bit field or an enumeration */
+    $: GirInfoAttrs & {
+        /** name of the member */
+        name: string;
+        /** value of the member */
+        value: string;
+        /** corresponding C type of the member */
+        'c:identifier': string;
+        /** short nickname of the member (from GEnumValue/GFlagsValue) */
+        'glib:nick'?: string;
+        /** name of the member (from GEnumValue/GFlagsValue) */
+        'glib:name'?: string;
+    };
+    _tsData?: TsMember;
+}

package/lib/types/gir-member-element.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gir-member-element.js.map

package/lib/types/gir-member-element.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gir-member-element.js","sourceRoot":"","sources":["../../src/types/gir-member-element.ts"],"names":[],"mappings":""}

package/lib/types/gir-method-element.d.ts

@@ -0,0 +1,13 @@
+import { GirDocElement, GirInfoAttrs, GirCallableAttrs, GirCallableParams, GirCallableReturn, TsMethod, PartOfClass } from './index.js';
+export interface GirMethodElement extends PartOfClass, GirDocElement {
+    /** element defining a method from a class */
+    $: GirInfoAttrs & GirCallableAttrs & {
+        /** The GObject property that is set by this method */
+        'glib:set-property': string;
+        /** The GObject property that is retrieved by this method */
+        'glib:get-property': string;
+    };
+    parameters?: [GirCallableParams];
+    'return-value'?: GirCallableReturn[];
+    _tsData?: TsMethod;
+}

package/lib/types/gir-method-element.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gir-method-element.js.map

package/lib/types/gir-method-element.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gir-method-element.js","sourceRoot":"","sources":["../../src/types/gir-method-element.ts"],"names":[],"mappings":""}

package/lib/types/gir-module-resolved-by.d.ts

@@ -0,0 +1,10 @@
+import { GirModule } from '../gir-module';
+import { ResolveType } from './resolve-type';
+export interface GirModuleResolvedBy {
+    module: GirModule;
+    resolvedBy: ResolveType;
+    /**
+     * E.g. Gtk-3.0
+     */
+    packageName: string;
+}

package/lib/types/gir-module-resolved-by.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gir-module-resolved-by.js.map

package/lib/types/gir-module-resolved-by.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gir-module-resolved-by.js","sourceRoot":"","sources":["../../src/types/gir-module-resolved-by.ts"],"names":[],"mappings":""}

package/lib/types/gir-modules-grouped-map.d.ts

@@ -0,0 +1,4 @@
+import { GirModulesGrouped } from './gir-modules-grouped';
+export interface GirModulesGroupedMap {
+    [id: string]: GirModulesGrouped;
+}

package/lib/types/gir-modules-grouped-map.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gir-modules-grouped-map.js.map

package/lib/types/gir-modules-grouped-map.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gir-modules-grouped-map.js","sourceRoot":"","sources":["../../src/types/gir-modules-grouped-map.ts"],"names":[],"mappings":""}

package/lib/types/gir-modules-grouped.d.ts

@@ -0,0 +1,12 @@
+import { GirModuleResolvedBy } from './gir-module-resolved-by';
+/**
+ * Grouped gir modules by basename like Gtk for Gtk-2.0, Gtk-3.0 and Gtk-4.0
+ */
+export interface GirModulesGrouped {
+    modules: GirModuleResolvedBy[];
+    hasConflict: boolean;
+    /**
+     * E.g. Gtk
+     */
+    namespace: string;
+}

package/lib/types/gir-modules-grouped.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gir-modules-grouped.js.map

package/lib/types/gir-modules-grouped.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gir-modules-grouped.js","sourceRoot":"","sources":["../../src/types/gir-modules-grouped.ts"],"names":[],"mappings":""}

package/lib/types/gir-namespace.d.ts

@@ -0,0 +1,30 @@
+import { GirInfoAttrs, GirInterfaceElement, GirRecordElement, GirUnionElement, GirEnumElement, GirAliasElement, GirFunctionElement, GirClassElement, GirBitfieldElement, GirCallbackElement, GirConstantElement, GirAnnotation, GirBoxedElement } from './index.js';
+/** Namespace which maps metadata entries to C functionality. This a similar concept to namespace in C++, but for GObject-based C libraries */
+export interface GirNamespace {
+    $: GirInfoAttrs & {
+        /** name of the namespace. For example, 'Gtk' (technically optional) */
+        name: string;
+        /** version number of the namespace (technically optional) */
+        version: string;
+        /** prefixes to filter out from C identifiers for data structures and types. For example, GtkWindow will be Window. If c:symbol-prefixes is not used, then this element is used for both */
+        'c:identifier-prefixes'?: string;
+        /** prefixes to filter out from C functions. For example, gtk_window_new will lose gtk_ */
+        'c:symbol-prefixes'?: string;
+        /** @deprecated the same as c:identifier-prefixes. Only used for backward compatibility  */
+        'c:prefix'?: string;
+        /** Path to the shared library implementing the namespace. It can be a comma-separated list, with relative path only */
+        'shared-library'?: string;
+    };
+    alias?: GirAliasElement[];
+    class?: GirClassElement[];
+    interface?: GirInterfaceElement[];
+    record?: GirRecordElement[];
+    enumeration?: GirEnumElement[];
+    function?: GirFunctionElement[];
+    union?: GirUnionElement[];
+    bitfield?: GirBitfieldElement[];
+    callback?: GirCallbackElement[];
+    constant?: GirConstantElement[];
+    annotation?: GirAnnotation[];
+    ['glib:boxed']?: GirBoxedElement[];
+}

package/lib/types/gir-namespace.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gir-namespace.js.map

package/lib/types/gir-namespace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gir-namespace.js","sourceRoot":"","sources":["../../src/types/gir-namespace.ts"],"names":[],"mappings":""}

package/lib/types/gir-package.d.ts

@@ -0,0 +1,7 @@
+export interface GirPackage {
+    /** @deprecated package name containing the library */
+    $: {
+        /** name of the package */
+        name: string;
+    };
+}

package/lib/types/gir-package.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gir-package.js.map

package/lib/types/gir-package.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gir-package.js","sourceRoot":"","sources":["../../src/types/gir-package.ts"],"names":[],"mappings":""}

package/lib/types/gir-prerequisite.d.ts

@@ -0,0 +1,5 @@
+export interface GirPrerequisite {
+    $: {
+        name?: string;
+    };
+}

package/lib/types/gir-prerequisite.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gir-prerequisite.js.map

package/lib/types/gir-prerequisite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gir-prerequisite.js","sourceRoot":"","sources":["../../src/types/gir-prerequisite.ts"],"names":[],"mappings":""}

package/lib/types/gir-property-element.d.ts

@@ -0,0 +1,21 @@
+import { GirBoolean, GirInfoAttrs, GirInfoElements, GirAnyType, GirTransferOwnership, PartOfClass, TsProperty } from './index.js';
+export interface GirPropertyElement extends PartOfClass, GirInfoElements, GirAnyType {
+    /** Property, that is a variable or members with getter and setter functions */
+    $: GirInfoAttrs & {
+        /** name of the property */
+        name: string;
+        /** Binary attribute, true if the property is writeable, that is it has a setter function */
+        writable?: GirBoolean;
+        /** Binary attribute, true if the property is readable, that is it has a getter function */
+        readable?: GirBoolean;
+        /** Binary attribute, true if the property will be set upon construction */
+        construct?: GirBoolean;
+        /** Binary attribute, true if the property can only be set upon construction */
+        'construct-only'?: GirBoolean;
+        /** The setter function for this property */
+        setter?: string;
+        /** The getter function for this property */
+        getter?: string;
+    } & Partial<GirTransferOwnership>;
+    _tsData?: TsProperty;
+}

package/lib/types/gir-property-element.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gir-property-element.js.map

package/lib/types/gir-property-element.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gir-property-element.js","sourceRoot":"","sources":["../../src/types/gir-property-element.ts"],"names":[],"mappings":""}

package/lib/types/gir-record-element.d.ts

@@ -0,0 +1,30 @@
+import { GirBoolean, GirInfoElements, GirInfoAttrs, GirFieldElement, GirFunctionElement, GirUnionElement, GirMethodElement, GirConstructorElement, GirPropertyElement, PartOfModule, TsClass } from './index.js';
+export interface GirRecordElement extends PartOfModule, GirInfoElements {
+    /** Record definition, equivalent to a C struct, that is a simple structure, not a class */
+    $: GirInfoAttrs & {
+        /** name of the record */
+        name: string;
+        /** Corresponding C type of the record */
+        'c:type'?: string;
+        /** Binary attribute to tell if the record is disguised, i.e. whether the c:type is a typedef that doesn't look like a pointer, but is one internally */
+        /** Its second meaning is "private" and is set when any typedef struct is parsed which doesn't also include a full struct with fields (https://gitlab.gnome.org/GNOME/gobject-introspection/issues/101) */
+        disguised?: GirBoolean;
+        /** GObject compatible C type of the record */
+        'glib:type-name'?: string;
+        /** Function to get the GObject compatible type of the record */
+        'glib:get-type'?: string;
+        /** prefix to filter out from C functions. For example, gtk_window_new will lose gtk_ */
+        'c:symbol-prefix'?: string;
+        /** Binary attribute to tell if the record is foreign, that is it is not available in a g-i supported library */
+        foreign?: GirBoolean;
+        /** Name of the GObject compatible gtype this record represents. If }, this record will be hidden from generated public APIs. */
+        'glib:is-gtype-struct-for'?: string;
+    };
+    field?: GirFieldElement[];
+    function?: GirFunctionElement[];
+    union?: GirUnionElement[];
+    method?: GirMethodElement[];
+    constructor?: GirConstructorElement[];
+    property?: GirPropertyElement[];
+    _tsData?: TsClass;
+}

package/lib/types/gir-record-element.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gir-record-element.js.map

package/lib/types/gir-record-element.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gir-record-element.js","sourceRoot":"","sources":["../../src/types/gir-record-element.ts"],"names":[],"mappings":""}

package/lib/types/gir-repository.d.ts

@@ -0,0 +1,16 @@
+import { GirInclude, GirNamespace, GirCInclude, GirPackage } from './index.js';
+/** Root node of a GIR repository. It contains  namespaces, which can in turn be implemented in several libraries */
+export interface GirRepository {
+    $: {
+        /** version number of the repository */
+        version?: string;
+        /** prefixes to filter out from C identifiers for data structures and types. For example, GtkWindow will be Window. If c:symbol-prefixes is not used, then this element is used for both */
+        'c:identifier-prefixes'?: string;
+        /** prefixes to filter out from C functions. For example, gtk_window_new will lose gtk_ */
+        'c:symbol-prefixes'?: string;
+    };
+    include?: GirInclude[];
+    'c:include': GirCInclude[];
+    package: GirPackage[];
+    namespace?: GirNamespace[];
+}

package/lib/types/gir-repository.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gir-repository.js.map

package/lib/types/gir-repository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gir-repository.js","sourceRoot":"","sources":["../../src/types/gir-repository.ts"],"names":[],"mappings":""}

package/lib/types/gir-signal.d.ts

@@ -0,0 +1,25 @@
+import { GirCallableReturn, GirBoolean, GirInfoAttrs, GirInfoElements, GirCallableParams, PartOfModule, GirClassElement, GirRecordElement, GirInterfaceElement, TsSignal } from './index.js';
+export interface GirSignalElement extends PartOfModule, GirInfoElements {
+    /** A signal as defined in the GObject system (https://docs.gtk.org/gobject/concepts.html#signals) */
+    $: GirInfoAttrs & {
+        /** name of the signal */
+        name: string;
+        /** Binary attribute, true if the signal has a detailed parameter (https://docs.gtk.org/gobject/concepts.html#the-detail-argument and https://docs.gtk.org/gobject/flags.SignalFlags.html) */
+        detailed?: GirBoolean;
+        /** When to run the signal during the 5 steps of signal emission (https://docs.gtk.org/gobject/concepts.html#signal-emission and https://docs.gtk.org/gobject/flags.SignalFlags.html) */
+        when?: 'first' | 'last' | 'cleanup';
+        /** Binary attribute, true if the signal can be freely emitted on alive objects from user code (https://docs.gtk.org/gobject/flags.SignalFlags.html) */
+        action?: GirBoolean;
+        /** Binary attribute, true if no emission hooks are supported for this signal (https://docs.gtk.org/gobject/flags.SignalFlags.html) */
+        'no-hooks'?: GirBoolean;
+        /** Binary attribute, true if signals emitted for an object while currently being in emission for this very object will not be emitted recursively, but instead cause the first emission to be restarted (https://docs.gtk.org/gobject/flags.SignalFlags.html) */
+        'no-recurse'?: GirBoolean;
+    };
+    parameters?: [GirCallableParams];
+    'return-value'?: GirCallableReturn[];
+    /**
+     * The class this function is defined in
+     */
+    _class?: GirClassElement | GirRecordElement | GirInterfaceElement;
+    _tsData?: TsSignal;
+}

package/lib/types/gir-signal.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gir-signal.js.map

package/lib/types/gir-signal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gir-signal.js","sourceRoot":"","sources":["../../src/types/gir-signal.ts"],"names":[],"mappings":""}

package/lib/types/gir-transfer-ownership-type.d.ts

@@ -0,0 +1,5 @@
+export declare enum GirTransferOwnershipType {
+    Container = "container",
+    Full = "full",
+    None = "none"
+}

package/lib/types/gir-transfer-ownership-type.js

@@ -0,0 +1,7 @@
+export var GirTransferOwnershipType;
+(function (GirTransferOwnershipType) {
+    GirTransferOwnershipType["Container"] = "container";
+    GirTransferOwnershipType["Full"] = "full";
+    GirTransferOwnershipType["None"] = "none";
+})(GirTransferOwnershipType || (GirTransferOwnershipType = {}));
+//# sourceMappingURL=gir-transfer-ownership-type.js.map

package/lib/types/gir-transfer-ownership-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gir-transfer-ownership-type.js","sourceRoot":"","sources":["../../src/types/gir-transfer-ownership-type.ts"],"names":[],"mappings":"AAAA,MAAM,CAAN,IAAY,wBAIX;AAJD,WAAY,wBAAwB;IAChC,mDAAuB,CAAA;IACvB,yCAAa,CAAA;IACb,yCAAa,CAAA;AACjB,CAAC,EAJW,wBAAwB,KAAxB,wBAAwB,QAInC"}

package/lib/types/gir-transfer-ownership.d.ts

@@ -0,0 +1,5 @@
+import { GirTransferOwnershipType } from './gir-transfer-ownership-type';
+export interface GirTransferOwnership {
+    /** attributes used by many elements for the transfer of ownership, with for example, a returned value. "none" if the recipient does not own the value, "container" if the recipient owns the container but not the value (for arrays or lists for example) , "full" the recipient owns the entire value. For details, see https://wiki.gnome.org/Projects/GObjectIntrospection/Annotations#Memory_and_lifecycle_management */
+    'transfer-ownership': GirTransferOwnershipType;
+}

package/lib/types/gir-transfer-ownership.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gir-transfer-ownership.js.map

package/lib/types/gir-transfer-ownership.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gir-transfer-ownership.js","sourceRoot":"","sources":["../../src/types/gir-transfer-ownership.ts"],"names":[],"mappings":""}

package/lib/types/gir-type.d.ts

@@ -0,0 +1,14 @@
+import { GirArrayType, GirBoolean, GirInfoAttrs, GirDocElement } from './index.js';
+export interface GirType extends GirDocElement {
+    /** A simple type of data (as opposed to an array) */
+    $: GirInfoAttrs & {
+        /** name of the type */
+        name?: string;
+        /** the C representation of the type */
+        'c:type'?: string;
+        /** Binary attribute which is BinaryOption(false) if the element is not introspectable. It doesn't exist in the bindings, due in general to missing information in the annotations in the original C code */
+        introspectable?: GirBoolean;
+    };
+    array?: GirArrayType[];
+    type: GirType[];
+}

package/lib/types/gir-type.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gir-type.js.map

package/lib/types/gir-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gir-type.js","sourceRoot":"","sources":["../../src/types/gir-type.ts"],"names":[],"mappings":""}

package/lib/types/gir-union-element.d.ts

@@ -0,0 +1,22 @@
+import type { GirInfoElements, GirInfoAttrs, GirConstructorElement, GirMethodElement, GirFunctionElement, GirFieldElement, GirRecordElement, PartOfModule, TsClass } from './index.js';
+export interface GirUnionElement extends PartOfModule, GirInfoElements {
+    /** element defining a type of data being a union of type, similar to union in C/C++ but extended with fields and methods */
+    $: GirInfoAttrs & {
+        /** name of the union */
+        name?: string;
+        /** C type defining the union */
+        'c:type'?: string;
+        /** prefix to filter out from C functions. For example, gtk_window_new will lose gtk_ */
+        'c:symbol-prefix'?: string;
+        /** GObject compatible type name */
+        'glib:type-name'?: string;
+        /** function to retrieve the GObject compatible type of the element */
+        'glib:get-type'?: string;
+    };
+    field?: GirFieldElement[];
+    constructor?: GirConstructorElement[];
+    method?: GirMethodElement[];
+    function?: GirFunctionElement[];
+    record?: GirRecordElement[];
+    _tsData?: TsClass;
+}

package/lib/types/gir-union-element.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gir-union-element.js.map