@ts-for-gir/lib 3.0.0-beta.12 → 3.0.0

package/templates/{Gjs/index.d.ts → gjs/gjs.d.ts}

@@ -4,27 +4,220 @@
  * These type definitions are automatically generated, do not edit them by hand.
  * If you found a bug fix it in <%= APP_NAME %> itself or create a bug report on <%= APP_SOURCE %>
  */
+import './ambient.d.ts';
+
+<%_ const GObject = dep.find('GObject') _%>
+<%_ const GLib = dep.find('GLib') _%>
+<%- GObject ? GObject.importDef : '' %>
+<%- GLib ? GLib.importDef : '' %>
+import gettext from './gettext.js';
+import system from './system.js';
+import cairo from './cairo.js';
+
+// https://gitlab.gnome.org/GNOME/gjs/-/blob/1.72.0/modules/script/package.js
+declare namespace package {
+    /**
+     * Although there are references in the documentation of more properties that
+     * this object should accepts, only the following are actually used in the init code,
+     * and all the other have their values derived from them.
+     */
+    interface PackageInitParams {
+        name: string
+        version: string
+        prefix: string
+        libdir: string
+    }
 
-import type * as Gjs from './Gjs.js'
-<%_ if(gnomeShellTypes){ _%>
-import type * as GnomeShell from './GnomeShell.js'
-<%_ } _%>
-<%_ for (const girModule of girModules) { _%>
-  <%_ if(noNamespace){ _%>
-import type * as <%= girModule.importName %> from "./<%= girModule.packageName %>.js";
-  <%_ } else { _%>
-import type <%= girModule.importName %> from "./<%= girModule.packageName %>.js";
-  <%_ } _%>
-<%_ } _%>
+    export const name: string | undefined
+    export const version: string | undefined
+    export const prefix: string | undefined
+    export const datadir: string | undefined
+    export const libdir: string | undefined
+    export const pkgdatadir: string | undefined
+    export const pkglibdir: string | undefined
+    export const moduledir: string | undefined
+    export const localedir: string | undefined
+
+    export function init(params: PackageInitParams): void
+    export function run(module: { main: (argv: string[]) => void }): void
+    /** shortcut to init+run */
+    export function start(params: PackageInitParams): void
+    export function require(libs: Record<string, string>): void
+    export function requireSymbol(lib: string, ver: string, symbol: string): void
+    export function checkSymbol(lib: string, ver: string, symbol: string): void
+    export function initGettext(): void
+    /** @deprecated Use JS string interpolation */
+    export function initFormat(): void
+    export function initSubmodule(module: string): void
+}
+
+declare namespace byteArray {
+    export class ByteArray {
+        static get(target: any, property: string, receiver: any): any
+        static set(target: any, property: string, value: any, receiver: any): boolean
+
+        length: number
+        protected _array: Uint8Array
+
+        constructor(x: Uint8Array | number)
+        toString(encoding?: TextDecoderEncoding): string
+        fromString(input: string, encoding?: TextDecoderEncoding): ByteArray
+        toGBytes(): GLib.Bytes
+    }
+
+    /** @deprecated Use {@link TextEncoder.encode} instead */
+    export function fromString(input: string, encoding?: TextDecoderEncoding): Uint8Array
+
+    /** @deprecated Use {@link GLib.Bytes.toArray} instead */
+    export function fromGBytes(input: GLib.Bytes): Uint8Array
+
+    /** @deprecated Use {@link TextEncoder.encode} instead */
+    export function toString(x: Uint8Array, encoding?: TextDecoderEncoding): string
+
+    /** @deprecated Use {@link GLib.Bytes new GLib.Bytes() } instead */
+    export function toGBytes(x: Uint8Array): GLib.Bytes
+
+    /** @deprecated Use {@link ByteArray new ByteArray()} instead */
+    export function fromArray(array: Iterable<number>): ByteArray
+}
+
+declare namespace console {
+    export function interact(): void
+}
+
+declare namespace lang {
+    // TODO: There is a lot more in Lang
+    export function Class(props: any): void
+}
+
+declare namespace format {
+    export function vprintf(str: string, args: string[]): string
+    export function printf(fmt: string, ...args: any[]): void
+    // Following docs from gjs/modules/format.js
+    /**
+     * This function is intended to extend the String object and provide
+     * an String.format API for string formatting.
+     * It has to be set up using String.prototype.format = Format.format;
+     * Usage:
+     * "somestring %s %d".format('hello', 5);
+     * It supports %s, %d, %x and %f, for %f it also support precisions like
+     * "%.2f".format(1.526). All specifiers can be prefixed with a minimum
+     * field width, e.g. "%5s".format("foo"). Unless the width is prefixed
+     * with '0', the formatted string will be padded with spaces.
+     */
+    export function format(fmt: string, ...args: any[]): string
+}
+
+declare namespace mainloop {
+    export function quit(name: string): void
+    export function idle_source(handler: any, priority?: number): any
+    export function idle_add(handler: any, priority?: number): any
+    export function timeout_source(timeout: any, handler: any, priority?: number): any
+    export function timeout_seconds_source(timeout: any, handler: any, priority?: number): any
+    export function timeout_add(timeout: any, handler: any, priority?: number): any
+    export function timeout_add_seconds(timeout: any, handler: any, priority?: number): any
+    export function source_remove(id: any): any
+    export function run(name: string): void
+}
+
+/**
+ * You can use the `Signals.addSignalMethods` method to apply the `Signals` convenience methods to an `Object`.
+ * Generally, this is called on an object prototype, but may also be called on an object instance.
+ * You can use this Interface for this object or prototype to make the methods in typescript known
+ * @example
+ * ```ts
+ * const Signals = imports.signals;
+ * 
+ * // Define an interface with the same name of your class to make the methods known
+ * interface Events extends Signals.Methods {}
+ * 
+ * class Events {}
+ * Signals.addSignalMethods(Events.prototype);
+ * 
+ * const events = new Events();
+ * 
+ * // Typescript will not complain here
+ * events.emit("test-signal", "test argument");
+ * ```
+ */
+export interface SignalMethods {
+    /**
+     * Connects a callback to a signal for an object. Pass the returned ID to
+     * `disconect()` to remove the handler.
+     * 
+     * If `callback` returns `true`, emission will stop and no other handlers will be
+     * invoked.
+     * 
+     * > Warning: Unlike GObject signals, `this` within a signal callback will always
+     * > refer to the global object (ie. `globalThis`).
+     * 
+     * @param sigName A signal name
+     * @param callback A callback function
+     * @returns A handler ID
+     */
+    connect(sigName: string, callback: (self: any, ...args: any[]) => void): number;
+    /**
+     * Emits a signal for an object. Emission stops if a signal handler returns `true`.
+     * 
+     * Unlike GObject signals, it is not necessary to declare signals or define their
+     * signature. Simply call `emit()` with whatever signal name you wish, with
+     * whatever arguments you wish.
+     * @param sigName A signal name
+     * @param args Any number of arguments, of any type
+     */
+    emit(sigName: string, ...args: any[]): void;
+    /**
+     * Disconnects a handler for a signal.
+     * @param id The ID of the handler to be disconnected
+     */
+    disconnect(id: number): void;
+    /**
+     * Disconnects all signal handlers for an object.
+     */
+    disconnectAll(): void
+    /**
+     * Checks if a handler ID is connected.
+     * @param id The ID of the handler to be disconnected
+     * @returns `true` if connected, or `false` if not
+     */
+    signalHandlerIsConnected(id: number): boolean;
+}
+
+declare namespace signals {
+    export function addSignalMethods<T = any>(proto: T): proto is T & SignalMethods;
+}
 
 // See also https://github.com/microsoft/TypeScript/blob/main/lib/lib.dom.d.ts
 declare global {
+
+    interface GjsGiImports {
+        // Will be extended by the import of more gir types
+        versions: {
+            [namespace: string]: string
+        }
+    }
+    
+    interface GjsImports {
+        gi: GjsGiImports
+        lang: typeof lang
+        system: typeof system
+        signals: typeof signals
+        package: typeof package
+        mainloop: typeof mainloop
+        searchPath: string[]
+        gettext: typeof gettext
+        byteArray: typeof byteArray
+        format: typeof format
+        cairo: typeof cairo
+    }
+
     function print(...args: any[]): void
     function printerr(...args: any[]): void
     function log(message: any): void
     function logError(exception: object, message?: any): void
     function logError(message?: any): void
 
+    const pkg: typeof package
     interface Console {
         /**
          * Logs a critical message if the condition is not truthy.
@@ -48,15 +241,15 @@ declare global {
         clear(): void
 
         /**
-         * Logs a message with severity equal to {@link GLib20.LogLevelFlags.DEBUG}.
+         * Logs a message with severity equal to {@link GLib.LogLevelFlags.DEBUG}.
          *
          * @param  {...any} data formatting substitutions, if applicable
          */
         debug(...data: any[]): void
 
         /**
-         * Logs a message with severity equal to {@link GLib20.LogLevelFlags.CRITICAL}.
-         * Does not use {@link GLib20.LogLevelFlags.ERROR} to avoid asserting and
+         * Logs a message with severity equal to {@link GLib.LogLevelFlags.CRITICAL}.
+         * Does not use {@link GLib.LogLevelFlags.ERROR} to avoid asserting and
          * forcibly shutting down the application.
          *
          * @param data formatting substitutions, if applicable
@@ -64,14 +257,14 @@ declare global {
         error(...data: any[]): void
 
         /**
-         * Logs a message with severity equal to {@link GLib20.LogLevelFlags.INFO}.
+         * Logs a message with severity equal to {@link GLib.LogLevelFlags.INFO}.
          *
          * @param data formatting substitutions, if applicable
          */
         info(...data: any[]): void
 
         /**
-         * Logs a message with severity equal to {@link GLib20.LogLevelFlags.MESSAGE}.
+         * Logs a message with severity equal to {@link GLib.LogLevelFlags.MESSAGE}.
          *
          * @param data formatting substitutions, if applicable
          */
@@ -203,7 +396,7 @@ declare global {
     }
 
     <% if(!noDOMLib){ %>
-    const console: Console
+        const console: Console
     <% } %>
 
     // https://gitlab.gnome.org/GNOME/gjs/-/blob/1.73.2/modules/esm/_encoding/encodingMap.js#L7-232
@@ -512,15 +705,15 @@ declare global {
     <% } %>
 
     interface BooleanConstructor {
-        $gtype: GObject20.GType<boolean>
+        $gtype: GObject.GType<boolean>
     }
 
     interface NumberConstructor {
-        $gtype: GObject20.GType<number>
+        $gtype: GObject.GType<number>
     }
 
     interface StringConstructor {
-        $gtype: GObject20.GType<string>
+        $gtype: GObject.GType<string>
     }
 
     const ARGV: string[]
@@ -534,7 +727,7 @@ declare global {
      * @param delay the duration in milliseconds to wait before running callback
      * @param args arguments to pass to callback
      */
-    function setTimeout(callback: (...args: any[]) => any, delay?: number, ...args: any[]): GLib20.Source
+    function setTimeout(callback: (...args: any[]) => any, delay?: number, ...args: any[]): GLib.Source
 
     /**
      * @version Gjs 1.71.1
@@ -542,53 +735,23 @@ declare global {
      * @param delay the duration in milliseconds to wait between calling callback
      * @param args arguments to pass to callback
      */
-    function setInterval(callback: (...args: any[]) => any, delay?: number, ...args: any[]): GLib20.Source
+    function setInterval(callback: (...args: any[]) => any, delay?: number, ...args: any[]): GLib.Source
 
     /**
      * @version Gjs 1.71.1
      * @param timeout the timeout to clear
      */
-    function clearTimeout(timeout: GLib20.Source): void
+    function clearTimeout(timeout: GLib.Source): void
 
     /**
      * @version Gjs 1.71.1
      * @param timeout the timeout to clear
      */
-    function clearInterval(timeout: GLib20.Source): void
-
-    const imports: typeof Gjs & {
-        gi: {
-            <%_ for (const girModuleGroup of girModulesGrouped) { _%>
-              <%= girModuleGroup.namespace %>: <%_ for (const [i, girModule] of girModuleGroup.modules.entries()) { _%>
-                typeof <%= girModule.module.importName %>
-                <%_ if (i !== girModuleGroup.modules.length - 1) { _%>
-                  |
-                <%_ } _%>
-              <%_ } _%>
-            <%_ } _%>
-            versions: {
-                <%_ for (const girModuleGroup of girModulesGrouped) { _%>
-                  <%= girModuleGroup.namespace %>: <%_ for (const [i, girModule] of girModuleGroup.modules.entries()) { _%>
-                    '<%= girModule.module.version %>'
-                    <%_ if (i !== girModuleGroup.modules.length - 1) { _%>
-                      |
-                    <%_ } _%>
-                  <%_ } _%>
-                <%_ } _%>
-            }
-        }
-        lang: typeof Gjs.Lang
-        system: typeof Gjs.System
-        signals: typeof Gjs.Signals
-        package: typeof Gjs.Package
-        mainloop: typeof Gjs.Mainloop
-        searchPath: string[]
-        <%_ if(gnomeShellTypes){ _%>
-          misc: typeof GnomeShell.misc
-          ui: typeof GnomeShell.ui
-        <%_ } _%>
-    }
+    function clearInterval(timeout: GLib.Source): void
+
+    const imports: GjsImports
 }
 
-declare const _imports: typeof imports
+declare const _imports: GjsImports
 export default _imports
+export { _imports as imports }

package/templates/gjs/gjs.js

@@ -0,0 +1,10 @@
+const imports = globalThis.imports || {};
+
+<%_ if(moduleType === 'esm') { _%>
+export { imports }
+export default imports;
+<%_ } else { _%>  
+module.exports = imports;
+exports.default = imports;
+<%_ } _%>
+  

package/templates/{Gjs/GObject-2.0.d.ts → gjs/gobject-2.0.d.ts}

@@ -23,7 +23,7 @@ export interface MetaInfo<Props, Interfaces, Sigs> {
     Signals?: Sigs
     Implements?: Interfaces
     CssName?: string
-    Template?: Uint8Array | GLib.Bytes
+    Template?: Uint8Array | GLib.Bytes | string
     Children?: string[]
     InternalChildren?: string[]
 }

package/templates/gjs/module-ambient.d.ts

@@ -0,0 +1,31 @@
+<%#
+    This EJS template is used for the generated .d.ts files for ambient typescript module support.
+    See https://www.typescriptlang.org/docs/handbook/modules.html#ambient-modules
+%>
+<%_ const pkg = dep.get(girModule.namespace, girModule.version) _%>
+<%_ let moduleImportStr = ""; _%>
+<%_ if(package){ _%>
+    <%_ if(noNamespace){ _%>
+        <%_ moduleImportStr = `import * as ${girModule.importNamespace} from '${pkg.importPath}'`; _%>
+    <%_ } else { _%>
+        <%_ moduleImportStr = `import ${girModule.importNamespace} from '${pkg.importPath}'`; _%>
+    <%_ } _%>
+<%_ } else { _%>
+    <%_ if(noNamespace){ _%>
+        <%_ moduleImportStr = `const ${girModule.importNamespace}: typeof import('${pkg.importPath}')`; _%>
+    <%_ } else { _%>
+        <%_ moduleImportStr = `const ${girModule.importNamespace}: typeof import('${pkg.importPath}').default`; _%>
+    <%_ } _%>
+<%_ } _%>
+
+declare module 'gi://<%= name %>?version=<%= version %>' {
+    <%- moduleImportStr %>;
+    export default <%- girModule.importNamespace -%>;
+}
+
+<%_ if(!dep.hasConflict(name, version)){ _%>
+declare module 'gi://<%= name %>' {
+    <%- moduleImportStr %>;
+    export default <%- girModule.importNamespace -%>;
+}
+<%_ } _%>

package/templates/gjs/module-import.d.ts

@@ -0,0 +1,33 @@
+<%#
+    This EJS template is used to extend the global GjsGiImports interface with the GIR module, for `imports.gi[namespace] GJS GIR types`
+%>
+<%_ if(!package && !dep.isLatestVersion(girModule.namespace, girModule.version)){ _%>
+<%_ return `// Module import type definition not generated, otherwise this would cause a type conflict, this is because several GIR modules were generated with the same namespace: "${ girModule.namespace }"` _%>
+<%_ } _%>
+
+<%_ const pkg = dep.get(girModule.namespace, girModule.version) _%>
+<%_ if(package){ _%>
+    <%_ if(noNamespace){ _%>
+import * as <%= girModule.importNamespace %> from '<%= pkg.importPath %>';
+    <%_ } else { _%>
+import <%= girModule.importNamespace %> from '<%= pkg.importPath %>';
+    <%_ } _%>
+<%_ } else { _%>
+    <%_ if(noNamespace){ _%>
+type <%= girModule.importNamespace %> = typeof import('<%= pkg.importPath %>');
+    <%_ } else { _%>
+type <%= girModule.importNamespace %> = typeof import('<%= pkg.importPath %>').default;
+    <%_ } _%>
+<%_ } _%>
+
+declare global {
+    export interface GjsGiImports {
+        <%_ if(package){ _%>
+        <%= name %>: typeof <%= girModule.importNamespace %>;
+        <%_ } else { _%>
+        <%= name %>: <%= girModule.importNamespace %>;
+        <%_ } _%>
+    }
+}
+
+export default GjsGiImports;

package/templates/gjs/module.append.d.ts

@@ -0,0 +1 @@
+// END

package/templates/gjs/module.d.ts

@@ -0,0 +1,12 @@
+<%# This EJS template is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ... %>
+/*
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `<%= APP_NAME %>` or create a bug report on <%= APP_SOURCE %>
+ */
+
+<%_ if(package){ _%>
+import './<%= importName %>-ambient.d.ts';
+<%_ } _%>
+import './<%= importName %>-import.d.ts';

package/templates/gjs/module.js

@@ -0,0 +1,17 @@
+<%# This template is used for the generated `.js` file of each GIR module like Gtk-4.0, GObject-2.0, ... %>
+<% if(moduleType === 'esm'){ %>
+  // @ts-expect-error
+  import <%= name %> from 'gi://<%= name %>?version=<%= version %>';
+  export { <%= name %> };
+  export default <%= name %>;
+<% } else { %>
+  imports.gi.versions.<%= name %> = '<%= version %>'
+  const <%= name %> = imports.gi.<%= name %>;
+  <% if(!noNamespace){ %>
+    module.exports = { <%= name %> };
+    exports.default = <%= name %>;
+  <% } else { %>
+    module.exports = <%= name %>;
+  <% } %>
+<% } %>
+

package/templates/gjs/system.d.ts

@@ -0,0 +1,32 @@
+<%_ const GObject = dep.find('GObject') _%>
+<%- GObject ? GObject.importDef : '' %>
+
+export const programInvocationName: string
+export const version: number
+export const programPath: string | null
+/** Equal to ARGV */
+export const programArgs: string[]
+export function exit(code: number): void
+export function addressOfGObject(o: GObject.Object): object
+export function addressOf(o: any): object
+/** Runs the garbage collector */
+export function gc(): void
+export function refcount(o: GObject.Object): number
+export function dumpHeap(path: string): void
+export function dumpMemoryInfo(path: string): void
+
+declare const System: {
+    programInvocationName: typeof programInvocationName,
+    version: typeof version,
+    programPath: typeof programPath,
+    programArgs: typeof programArgs,
+    exit: typeof exit,
+    addressOfGObject: typeof addressOfGObject,
+    addressOf: typeof addressOf,
+    gc: typeof gc,
+    refcount: typeof refcount,
+    dumpHeap: typeof dumpHeap,
+    dumpMemoryInfo: typeof dumpMemoryInfo,
+}
+
+export default System

package/templates/gjs/system.js

@@ -0,0 +1,11 @@
+<% if(moduleType === 'esm') { %>
+import System, { programInvocationName, version, programPath, programArgs, exit, addressOfGObject, addressOf, gc, refcount, dumpHeap, dumpMemoryInfo } from 'system';
+
+export { programInvocationName, version, programPath, programArgs, exit, addressOfGObject, addressOf, gc, refcount, dumpHeap, dumpMemoryInfo };
+export default System;
+<% } else { %>
+const System = imports.system;
+
+module.exports = System;
+exports.default = System;
+<% } %>

package/templates/gjs/tsconfig.alias.json

@@ -0,0 +1,12 @@
+<%# This template is used if the Option `generateAlias` is enabled %>
+{
+    "compilerOptions": {   
+        "baseUrl": ".",
+        "paths": { <% girModules.forEach(function(module, idx) { %>
+            <%_ const pkg = dep.get(module.namespace, module.version) _%>
+            <%_ const path = package ? join(typeDir, pkg.importName, pkg.importName) : join(typeDir, pkg.importName) _%>
+            "gi://<%= module.namespace %>?version=<%= module.version %>": ["<%= path %>.d.ts"]<% if (idx < girModules.length - 1) { %>,<% } %><% }); %>
+        }
+    },
+    "include": ["<%= typeDir %>/*.ts"]
+}

package/templates/node-gtk/README-NODE-GTK.md

@@ -0,0 +1,71 @@
+<%# This template is used if the Option `package` is enabled %>
+# <%- packageName %>
+
+<%- PACKAGE_DESC %> using [<%- APP_NAME %>](<%- APP_SOURCE %>) v<%- APP_VERSION %>.
+
+<%_ if (typeof pkgData !== 'undefined' && pkgData.description) { _%>
+<%- pkgData.description %>
+<%_ } else { _%>
+[node-gtk](https://github.com/romgrk/node-gtk) is a [GObject Introspection](https://gi.readthedocs.io/en/latest/) import library for Node.js. Using node-gtk with the type definitions in this NPM package, you can build GTK applications in JavaScript or TypeScript with type checking, better autocompletion and inline documentations.
+<%_ } _%>
+
+## Install
+
+To use this type definitions, install them with NPM:
+```bash
+npm install <%- npmScope %>/<%- importName %>
+```
+
+<%_ const pkg = dep.get(packageName) _%>
+<%_ if(!pkg){ _%>
+  <%_ return `Package with package name "${packageName}" not found!` _%>
+<%_ } _%>
+
+## Usage
+
+You can import this package into your project like this:
+```ts
+import <%- pkg.namespace %> from '<%- pkg.importPath %>';
+```
+
+Or if you prefer CommonJS, you can also use this:
+```ts
+const <%- pkg.namespace %> = require('<%- pkg.importPath %>');
+```
+
+### Ambient Modules
+
+You can import core [ambient module](https://github.com/gjsify/ts-for-gir/tree/main/packages/cli#ambient-modules) types.
+For this you need to include the `<%- npmScope %>/<%- importName %>` or `<%- npmScope %>/<%- importName %>/ambient` in your `tsconfig` or entry point Typescript file:
+    
+`index.ts`:
+```ts
+import '<%- npmScope %>/<%- importName %>'
+```
+
+`tsconfig.json`:
+```json
+{
+  "compilerOptions": {
+    ...
+  },
+  "include": ["<%- npmScope %>/<%- importName %>"],
+  ...
+}
+```
+
+Now you can import `node-gtk` with Typescript support:
+```ts
+const gi = require('node-gtk');
+gi.startLoop();
+```
+
+If you want to have types for [GObject Introspection](https://gi.readthedocs.io/en/latest/) modules, you have to add them to your dependencies and import them as well, see the description of these modules, e.g. [node-gtk-4.0](https://www.npmjs.com/package/@girs/node-gtk-4.0), [node-gio-2.0](https://www.npmjs.com/package/@girs/node-gio-2.0), [node-adw-1](https://www.npmjs.com/package/@girs/node-adw-1) and [much more](https://github.com/gjsify/types).
+
+### Bundle
+
+Depending on your project configuration, it is recommended to use a bundler like [esbuild](https://esbuild.github.io/). You can find examples using different bundlers [here](https://github.com/gjsify/ts-for-gir/tree/main/examples).
+
+## Other packages
+
+All existing pre-generated packages can be found on [gjsify/types](https://github.com/gjsify/types).

package/templates/node-gtk/ambient.d.ts

@@ -0,0 +1,19 @@
+// https://www.typescriptlang.org/docs/handbook/modules.html#ambient-modules
+// https://stackoverflow.com/questions/45099605/ambient-declaration-with-an-imported-type-in-typescript
+declare module 'node-gtk' {
+    <%_ const pkg = dep.getNodeGtk() _%>
+    <%_ if(package){ _%>
+        <% if(moduleType === 'esm'){ %>
+            import gi from '<%= pkg.importPath %>';
+        <% } else { %>  
+            import * as gi from '<%= pkg.importPath %>';
+        <% } %>
+    <%_ } else { _%>
+        <% if(moduleType === 'esm'){ %>
+            const gi: typeof import('<%= pkg.importPath %>').default;
+        <% } else { %>  
+            const gi: typeof import('<%= pkg.importPath %>');
+        <% } %>
+    <%_ } _%>
+    export = gi;
+}

package/templates/node-gtk/module-import.d.ts

@@ -0,0 +1,29 @@
+<%#
+    This EJS template is used to extend the global NodeGtkGi interface with the GIR module, for `gi.require(namespace) node-gtk GIR types`
+%>
+<%_ const pkg = dep.get(girModule.namespace, girModule.version) _%>
+<%_ if(package){ _%>
+    <%_ if(noNamespace){ _%>
+import * as <%= girModule.importNamespace %> from '<%= pkg.importPath %>';
+    <%_ } else { _%>
+import <%= girModule.importNamespace %> from '<%= pkg.importPath %>';
+    <%_ } _%>
+<%_ } else { _%>
+    <%_ if(noNamespace){ _%>
+type <%= girModule.importNamespace %> = typeof import('<%= pkg.importPath %>');
+    <%_ } else { _%>
+type <%= girModule.importNamespace %> = typeof import('<%= pkg.importPath %>').default;
+    <%_ } _%>
+<%_ } _%>
+
+declare global {
+    interface NodeGtkGi {
+        <%_ if(package){ _%>
+        require(ns: '<%= girModule.namespace %>', ver?: '<%= girModule.version %>'): typeof <%= girModule.importNamespace %>;
+        <%_ } else { _%>
+        require(ns: '<%= girModule.namespace %>', ver?: '<%= girModule.version %>'): <%= girModule.importNamespace %>;
+        <%_ } _%>
+    }
+}
+
+export default NodeGtkGi;

package/templates/node-gtk/module.append.d.ts

@@ -0,0 +1 @@
+// END