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

package/lib/types/dependency-map.js

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

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

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

package/lib/types/dependency.d.ts

@@ -0,0 +1,15 @@
+import { FileInfo } from './file-info.js';
+export interface Dependency extends FileInfo {
+    /**
+     * E.g. 'Gtk'
+     */
+    namespace: string;
+    /**
+     * E.g. '3.0'
+     */
+    version: string;
+    /**
+     * E.g. 'Gtk-3.0'
+     */
+    packageName: string;
+}

package/lib/types/dependency.js

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

package/lib/types/dependency.js.map

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

package/lib/types/environment.d.ts

@@ -0,0 +1 @@
+export type Environment = 'gjs' | 'node';

package/lib/types/environment.js

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

package/lib/types/environment.js.map

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

package/lib/types/file-info.d.ts

@@ -0,0 +1,14 @@
+export interface FileInfo {
+    /**
+     * The path to the gir file or null if the file does not exist
+     */
+    path: string | null;
+    /**
+     * The filename of the gir file
+     */
+    filename: string;
+    /**
+     * Whether the file exists or not
+     */
+    exists: boolean;
+}

package/lib/types/file-info.js

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

package/lib/types/file-info.js.map

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

package/lib/types/generate-config.d.ts

@@ -0,0 +1,34 @@
+import { BuildType, Environment, ModuleType } from './index.js';
+/**
+ * Type for currently used config e.g. in GirModule
+ */
+export interface GenerateConfig {
+    /** javascript environment */
+    environment: Environment;
+    /** directory to output to */
+    outdir: string | null;
+    /** Definitions generation type */
+    buildType?: BuildType;
+    /** Module type, can be CommonJS or ESM */
+    moduleType?: ModuleType;
+    /** GIR directories */
+    girDirectories: string[];
+    /** Switch on/off the verbose mode */
+    verbose: boolean;
+    /** Do not export all symbols for each module as a namespace */
+    noNamespace: boolean;
+    /** Do not generate documentation comments */
+    noComments: boolean;
+    /** Do not generate debugging inline comments */
+    noDebugComments: boolean;
+    /** Fix Inheritance and implementation type conflicts */
+    fixConflicts: boolean;
+    /** Disables the generation of types that are in conflict with the DOM types */
+    noDOMLib: boolean;
+    /** Generate types for GNOME Shell */
+    gnomeShellTypes: boolean;
+    /** Generate a tsconfig alias */
+    generateAlias: boolean;
+    /** Generate promisified functions for async/finish calls */
+    promisify: boolean;
+}

package/lib/types/generate-config.js

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

package/lib/types/generate-config.js.map

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

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

@@ -0,0 +1,13 @@
+import { GirInfoAttrs, GirInfoElements, GirType, PartOfClass, TsAlias } from './index.js';
+export interface GirAliasElement extends PartOfClass, GirInfoElements {
+    /** Type's name substitution, representing a typedef in C */
+    $: GirInfoAttrs & {
+        /** the new name or typedef'd name */
+        name: string;
+        /** the corresponding C type's name */
+        'c:type'?: string;
+    };
+    /** Other elements an alias can contain */
+    type?: GirType[];
+    _tsData?: TsAlias;
+}

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

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

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

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

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

@@ -0,0 +1,9 @@
+export interface GirAnnotation {
+    /** element defining an annotation from the source code, usually a user-defined annotation associated to a parameter or a return value */
+    $: {
+        /** name of the attribute */
+        name: string;
+        /** value of the attribute */
+        value: string[];
+    };
+}

package/lib/types/gir-annotation.js

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

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

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

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

@@ -0,0 +1,2 @@
+import { GirBitfieldElement, GirCallbackElement, GirClassElement, GirConstantElement, GirEnumElement, GirFunctionElement, GirInterfaceElement, GirRecordElement, GirUnionElement, GirAliasElement, GirMethodElement, GirVirtualMethodElement, GirSignalElement, GirConstructorElement, GirFieldElement, GirPropertyElement } from './index.js';
+export type GirAnyElement = GirBitfieldElement | GirCallbackElement | GirClassElement | GirConstantElement | GirEnumElement | GirFunctionElement | GirInterfaceElement | GirRecordElement | GirUnionElement | GirAliasElement | GirMethodElement | GirVirtualMethodElement | GirSignalElement | GirConstructorElement | GirFieldElement | GirPropertyElement;

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

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

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

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

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

@@ -0,0 +1,5 @@
+import { GirType, GirArrayType } from './index.js';
+export interface GirAnyType {
+    type?: GirType[];
+    array?: GirArrayType[];
+}

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

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

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

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

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

@@ -0,0 +1,20 @@
+import { GirInfoAttrs, GirUnparsedNumber, GirBoolean, GirType } from './index.js';
+export interface GirArrayType {
+    /** An array type of data where each element is of the same type */
+    $: GirInfoAttrs & {
+        /** name of the array type */
+        name?: string;
+        /** Binary attribute, true if the last element of the array is zero. For example, in an array of pointers, the last pointer would be NULL */
+        'zero-terminated'?: GirBoolean;
+        /** size of an array of predetermined fixed size. For example a C array declared as char arr[5]. */
+        'fixed-size'?: GirUnparsedNumber; /** integer */
+        /** 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;
+        /** 0-based index of parameter element that specifies the length of the array */
+        length?: GirUnparsedNumber; /** integer */
+        /** the C representation of the array type */
+        'c:type'?: string;
+    };
+    array?: GirArrayType[];
+    type?: GirType[];
+}

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

@@ -0,0 +1,3 @@
+// See https://gitlab.gnome.org/ewlsh/gi.ts/-/blob/master/packages/parser/src/xml.ts
+export {};
+//# sourceMappingURL=gir-array-type.js.map

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

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

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

@@ -0,0 +1,17 @@
+import { GirInfoAttrs, GirFunctionElement, GirInfoElements, GirMemberElement, TsEnum, PartOfModule } from './index.js';
+export interface GirBitfieldElement extends PartOfModule, GirInfoElements {
+    /** element defining a bit field (as in C) */
+    $: GirInfoAttrs & {
+        /** name of the bit field */
+        name: string;
+        /** corresponding C type of the bit field 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;
+    };
+    member: GirMemberElement[];
+    function: GirFunctionElement[];
+    _tsData?: TsEnum;
+}

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

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

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

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

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

@@ -0,0 +1 @@
+export type GirBoolean = '0' | '1';

package/lib/types/gir-boolean.js

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

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

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

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

@@ -0,0 +1,15 @@
+import { GirInfoAttrs, GirFunctionElement } from './index.js';
+export interface GirBoxedElement {
+    /** Boxed type (wrapper to opaque C structures registered by the type system) */
+    $: GirInfoAttrs & {
+        /** GObject compatible type name of the boxed type */
+        'glib:name': string;
+        /** prefix to filter out from C functions. For example, gtk_window_new will lose gtk_ */
+        'c:symbol-prefix'?: string;
+        /** GObject compatible type name of the boxed type */
+        'glib:type-name'?: string;
+        /** Function to get the GObject compatible type of the boxed type */
+        'glib:get-type'?: string;
+    };
+    function?: GirFunctionElement[];
+}

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

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

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

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

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

@@ -0,0 +1,7 @@
+export interface GirCInclude {
+    /** Dependant C header file which should be included in C programs */
+    $: {
+        /** File name of the C header file. The path can be relative. */
+        name: string;
+    };
+}

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

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

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

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

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

@@ -0,0 +1,15 @@
+import { GirBoolean } from './gir-boolean';
+/** Attributes of a Callable (functions, callbacks, closures, etc...) */
+export interface GirCallableAttrs {
+    /** name of the Callable */
+    name: string;
+    'c:identifier'?: string;
+    /** Callable it is shadowed by. For example, in C++, only one version of an overloaded callable will appear */
+    'shadowed-by'?: string;
+    /** Callable it shadows. For example, in C++, only one version of an overloaded callable will appear */
+    shadows?: string;
+    /** Binary attribute, true if the callable can throw an error */
+    throws?: GirBoolean;
+    /** if for backward compatibility reason the callable has a name in the source code but should be known by another one, this attribute contains the new name     */
+    'moved-to'?: string[];
+}

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

@@ -0,0 +1,3 @@
+// See https://gitlab.gnome.org/ewlsh/gi.ts/-/blob/master/packages/parser/src/xml.ts
+export {};
+//# sourceMappingURL=gir-callable-attrs.js.map

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

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

package/lib/types/gir-callable-param-element.d.ts

@@ -0,0 +1,30 @@
+import type { GirBoolean, GirUnparsedNumber, GirInfoAttrs, GirDocElement, GirAnyType, GirTransferOwnership, GirDirection, GirVarArgs, PartOfClass, TsParameter } from './index.js';
+export interface GirCallableParamElement extends PartOfClass, GirDocElement, GirAnyType {
+    /** parameter element of a list of parameters */
+    $: GirInfoAttrs & Partial<GirTransferOwnership> & {
+        /** name of the 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;
+        /** 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;
+        /** the parameter is a user_data for callbacks. The value points to a different parameter that is the actual callback */
+        closure?: GirUnparsedNumber; /** integer */
+        /** the parameter is a destroy_data for callbacks. The value points to a different parameter that is the actual callback */
+        destroy?: GirUnparsedNumber; /** integer */
+        /** the parameter is a callback, the value indicates the lifetime of the call. For language bindings which want to know when the resources required to do the call can be freed. "notified" valid until a GDestroyNotify argument is called, "async" only valid for the duration of the first callback invocation (can only be called once), "call" only valid for the duration of the call, can be called multiple times during the call.  */
+        scope?: 'notified' | 'async' | 'call';
+        /** 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;
+        /** Binary attribute, true if the parameter is optional */
+        optional?: GirBoolean;
+        /**  Binary attribute, true if the parameter can be omitted from the introspected output */
+        skip?: GirBoolean;
+    };
+    varargs?: GirVarArgs[];
+    _tsData?: TsParameter;
+}

package/lib/types/gir-callable-param-element.js

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

package/lib/types/gir-callable-param-element.js.map

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

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

@@ -0,0 +1,7 @@
+import { GirCallableParamElement, GirInstanceParameter } from './index.js';
+export interface GirCallableParams {
+    /** parameters element of a callable, that is in general parameters of a function or similar */
+    parameter: GirCallableParamElement[];
+    /** 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. */
+    'instance-parameter'?: GirInstanceParameter[];
+}

package/lib/types/gir-callable-param.js

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

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

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

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

@@ -0,0 +1,22 @@
+import { PartOfClass, GirTransferOwnership, GirDocElement, GirAnyType, GirUnparsedNumber, GirBoolean } from './index.js';
+export interface GirCallableReturn extends PartOfClass, GirAnyType, GirDocElement {
+    /** return value of a callable */
+    $: {
+        name?: 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;
+        /** Binary attribute, true if the parameter can have a null value */
+        nullable?: GirBoolean;
+        /** the parameter is a user_data for callbacks. The value points to a different parameter that is the actual callback */
+        closure?: GirUnparsedNumber; /** integer */
+        /** the parameter is a callback, the value indicates the lifetime of the call. For language bindings which want to know when the resources required to do the call can be freed. "notified" valid until a GDestroyNotify argument is called, "async" only valid for the duration of the first callback invocationi (can only be called once), "call" only valid for the duration of the call, can be called multiple times during the call.  */
+        scope?: 'notified' | 'async' | 'call';
+        /** the parameter is a destroy_data for callbacks. The value points to a different parameter that is the actual callback */
+        destroy?: GirUnparsedNumber; /** integer */
+        /**  Binary attribute, true if the parameter can be omitted from the introspected output */
+        skip?: GirBoolean;
+        /** @deprecated Replaced by nullable and optional */
+        'allow-none'?: GirBoolean;
+    } & Partial<GirTransferOwnership>;
+    girTypeName?: 'callable-return';
+}

package/lib/types/gir-callable-return.js

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

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

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

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

@@ -0,0 +1,15 @@
+import { GirBoolean, GirInfoElements, GirInfoAttrs, GirCallableParams, GirCallableReturn, PartOfModule, TsCallback } from './index.js';
+export interface GirCallbackElement extends PartOfModule, GirInfoElements {
+    /** A callback closure, that is a function called when a signal is emitted (as an answer to that signal) */
+    $: GirInfoAttrs & {
+        /** name of the callback */
+        name: string;
+        /** the C type returned by the callback closure (i.e. function) */
+        'c:type'?: string;
+        /** Binary attribute, true if the callback can throw an error */
+        throws?: GirBoolean;
+    };
+    parameters?: [GirCallableParams];
+    'return-value'?: GirCallableReturn[];
+    _tsData?: TsCallback;
+}

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

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

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

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

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

@@ -0,0 +1,48 @@
+import type { GirBoolean, GirInfoElements, GirInfoAttrs, PartOfModule, GirConstructorElement, GirImplements, GirMethodElement, GirFunctionElement, GirVirtualMethodElement, GirFieldElement, GirPropertyElement, GirSignalElement, GirUnionElement, GirConstantElement, GirRecordElement, GirCallbackElement, TsClass } from './index.js';
+export interface GirClassElement extends PartOfModule, GirInfoElements {
+    /** GObject inherited class definition */
+    $: GirInfoAttrs & {
+        /** Name of the class */
+        name: string;
+        /** GObject compatible type name of the class */
+        'glib:type-name': string;
+        /** Function to get the GObject compatible type of the class */
+        'glib:get-type': string;
+        /** Name of the parent class if any */
+        parent?: string;
+        /** GObject compatible C structure defining the class */
+        'glib:type-struct'?: string;
+        /** GObject compatible function to reference or increase the reference count of the class */
+        'glib:ref-func'?: string;
+        /** GObject compatible function to unreference or decrease the reference count of the class */
+        'glib:unref-func'?: string;
+        /** GObject compatible function to set a value of a property of the class */
+        'glib:set-value-func'?: string;
+        /** GObject compatible function to get a value of a property of the class */
+        'glib:get-value-func'?: string;
+        /** C type of the class */
+        'c:type'?: string;
+        /** prefix to filter out from C functions. For example, gtk_window_new will lose gtk_ */
+        'c:symbol-prefix'?: string;
+        /** Binary attribute to declare the class abstract or not */
+        abstract?: GirBoolean;
+        /** Binary attribute to declare the class fundamental or not (top-level class which do not derives from any other type) */
+        'glib:fundamental'?: GirBoolean;
+        /** Binary attribute to declare the class final or not (non-derivable class in a derivable hierarchy) */
+        final: GirBoolean;
+    };
+    implements?: GirImplements[];
+    constructor?: GirConstructorElement[];
+    method?: GirMethodElement[];
+    function?: GirFunctionElement[];
+    'virtual-method'?: GirVirtualMethodElement[];
+    field?: GirFieldElement[];
+    property?: GirPropertyElement[];
+    signal?: GirSignalElement[];
+    'glib:signal'?: GirSignalElement[];
+    union?: GirUnionElement[];
+    constant?: GirConstantElement[];
+    record?: GirRecordElement[];
+    callback?: GirCallbackElement[];
+    _tsData?: TsClass;
+}

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

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

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

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

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

@@ -0,0 +1,15 @@
+import type { GirInfoElements, GirAnyType, GirInfoAttrs, PartOfModule, TsVar } from './index.js';
+export interface GirConstantElement extends PartOfModule, GirInfoElements, GirAnyType {
+    /** A constant entity, similar to const variable in C */
+    $: GirInfoAttrs & {
+        /** name of the constant */
+        name: string;
+        /** value of the constant */
+        value: string;
+        /** corresponding C type of the constant in C */
+        'c:type'?: string;
+        /** corresponding C identifier in the source code */
+        'c:identifier'?: string;
+    };
+    _tsData?: TsVar;
+}

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

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

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

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

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

@@ -0,0 +1,8 @@
+import { GirInfoAttrs, GirCallableAttrs, GirCallableParams, GirCallableReturn, PartOfClass, TsFunction } from './index.js';
+export interface GirConstructorElement extends PartOfClass {
+    /** A constructor of a class */
+    $: GirInfoAttrs & GirCallableAttrs;
+    parameters?: [GirCallableParams];
+    'return-value'?: GirCallableReturn[];
+    _tsData?: TsFunction;
+}

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

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

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

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

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

@@ -0,0 +1,5 @@
+export declare enum GirDirection {
+    In = "in",
+    Inout = "inout",
+    Out = "out"
+}

package/lib/types/gir-direction.js

@@ -0,0 +1,7 @@
+export var GirDirection;
+(function (GirDirection) {
+    GirDirection["In"] = "in";
+    GirDirection["Inout"] = "inout";
+    GirDirection["Out"] = "out";
+})(GirDirection || (GirDirection = {}));
+//# sourceMappingURL=gir-direction.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gir-direction.js","sourceRoot":"","sources":["../../src/types/gir-direction.ts"],"names":[],"mappings":"AAAA,MAAM,CAAN,IAAY,YAIX;AAJD,WAAY,YAAY;IACpB,yBAAS,CAAA;IACT,+BAAe,CAAA;IACf,2BAAW,CAAA;AACf,CAAC,EAJW,YAAY,KAAZ,YAAY,QAIvB"}

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

@@ -0,0 +1,68 @@
+export interface GirDocElement {
+    /** Version of the documentation */
+    'doc-version'?: [
+        {
+            $: {
+                /** Preserve the original formatting of the documentation from the source code */
+                'xml:space'?: 'preserve';
+                /** Preserve the original formatting of the documentation from the source code. Recommended to use this instead of xml:space */
+                'xml:whitespace'?: 'preserve';
+            };
+            /** the text of the version of the documentation */
+            _: string;
+        }
+    ];
+    /** give the stability of the documentation */
+    'doc-stability'?: [
+        {
+            $: {
+                /** Preserve the original formatting of the documentation from the source code */
+                'xml:space'?: 'preserve';
+                /** Preserve the original formatting of the documentation from the source code. Recommended to use this instead of xml:space */
+                'xml:whitespace'?: 'preserve';
+            };
+            _: string;
+        }
+    ];
+    /** documentation of an element */
+    doc: [
+        {
+            $: {
+                /** Preserve the original formatting of the documentation from the source code */
+                'xml:space'?: 'preserve';
+                /** Keep the whitespace as they were in the source code */
+                'xml:whitespace'?: 'preserve';
+                /** The file containing this documentation */
+                filename: string;
+                /** The first line of the documentation in the source code */
+                line: string;
+                /** The first column of the documentation in the source code */
+                column: string;
+            };
+            _: string;
+        }
+    ];
+    /** Deprecated documentation of an element. Kept for historical reasons in general */
+    'doc-deprecated': [
+        {
+            $: {
+                /** Preserve the original formatting of the documentation from the source code */
+                'xml:space'?: 'preserve';
+                /** Keep the whitespace as they were in the source code */
+                'xml:whitespace'?: 'preserve';
+            };
+            _: string;
+        }
+    ];
+    /** Position of the documentation in the original source code */
+    'source-position': [
+        {
+            /** File name of the source of the documentation */
+            filename: string;
+            /** The first line of the documentation in the source code */
+            line: string;
+            /** The first column of the documentation in the source code */
+            column: string[];
+        }
+    ];
+}

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

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