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

package/templates/Gjs/ui/layout.d.ts

@@ -0,0 +1,311 @@
+// https://gitlab.gnome.org/GNOME/gnome-shell/-/blob/main/js/ui/layout.js
+
+<% const Gio = dep.find('Gio') %>
+<% const Clutter = dep.find('Clutter') %>
+<% const St = dep.find('St') %>
+<% const Meta = dep.find('Meta') %>
+
+<%_ if(noNamespace){ _%>
+    import type * as Gio from '../<%= Gio.packageName %>.js';
+    import type * as Clutter from '../<%= Clutter.packageName %>.js';
+    import type * as St from '../<%= St.packageName %>.js';
+    import type * as Meta from '../<%= Meta.packageName %>.js';
+<%_ } else { _%>
+    import type Gio from '../<%= Gio.packageName %>.js';
+    import type Clutter from '../<%= Clutter.packageName %>.js';
+    import type St from '../<%= St.packageName %>.js';
+    import type Meta from '../<%= Meta.packageName %>.js';
+<%_ } _%>
+
+import { EventEmitter } from '../misc/signals.js';
+
+import type { DragMotionResult } from './dnd.js';
+import type { SystemBackground } from './background.js';
+import type { Ripples } from './ripples.js';
+import type { BackgroundManager } from './background.js';
+
+export interface Geometry {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+export class MonitorConstraint extends Clutter.Constraint {
+
+    protected _primary: boolean;
+    protected _index: number;
+    protected _workArea: boolean;
+
+    public primary: boolean;
+    public index: number;
+    public workArea: boolean;
+
+    constructor(props: Clutter.Constraint.ConstructorProperties);
+    public _init(props: Clutter.Constraint.ConstructorProperties): void;
+
+    public vfunc_update_allocation(actor: Clutter.Actor, actorBox: Clutter.ActorBox): void;
+}
+
+declare class Monitor {
+
+    public index: number;
+    public geometryScale: number;
+    public x: number;
+    public y: number;
+    public width: number;
+    public height: number;
+    public readonly inFullscreen: boolean;
+
+    constructor(index: number, geometry: Geometry, geometryScale: number);
+}
+
+declare class UiActor extends St.Widget {
+    public constructor(props?: St.Widget.ConstructorProperties);
+    public _init(props?: St.Widget.ConstructorProperties): void;
+
+    public vfunc_get_preferred_width(_forHeight: number): [number, number];
+    public vfunc_get_preferred_height(_forWidth: number): [number, number];
+}
+
+declare class ScreenTransition extends Clutter.Actor {
+    constructor();
+
+    /** @hidden */
+    public _init(params?: Clutter.Actor.ConstructorProperties): void;
+    public _init(): void;
+
+    public run(): void;
+}
+
+/**
+ * This class manages a "hot corner" that can toggle switching to
+ * overview.
+ */
+declare class HotCorner extends Clutter.Actor {
+
+    protected _entered: boolean;
+    protected _monitor: Monitor;
+    protected _x: number;
+    protected _y: number;
+    protected _pressureBarrier: PressureBarrier;
+    protected _ripples: Ripples;
+
+    constructor(layoutManager: LayoutManager, monitor: Monitor, x: number, y: number);
+
+    public _init(props?: Clutter.Actor.ConstructorProperties): void;
+    public _init(layoutManager: LayoutManager, monitor: Monitor, x: number, y: number): void;
+
+    public setBarrierSize(size: number): void;
+    public handleDragOver(source: any, actor: any, x: number, y: number, time: number): DragMotionResult;
+
+    protected _setupFallbackCornerIfNeeded(layoutManager: LayoutManager): void;
+    protected _onDestroy(): void;
+    protected _toggleOverview(): void;
+    protected _onCornerEntered(): void;
+    protected _onCornerLeft(actor: Clutter.Actor, event: Clutter.Event): void;
+}
+
+export class LayoutManager extends GObject.Object {
+
+    protected _rtl: boolean;
+    protected _keyboardIndex: number;
+    protected _rightPanelBarrier: Meta.Barrier | null;
+    protected _inOverview: boolean;
+    protected _updateRegionIdle: number;
+    protected _trackedActors: { trackFullscreen: boolean; affectsStruts: boolean; affectsInputRegion: boolean; }[];
+    protected _keyboardHeightNotifyId: number;
+    protected _backgroundGroup: Meta.BackgroundGroup;
+    protected _interfaceSettings: Gio.Settings;
+    protected _pendingLoadBackground: boolean;
+    protected _systemBackground: SystemBackground;
+
+    public monitors: Monitor[];
+    public primaryMonitor: Monitor | null;
+    public primaryIndex: number;
+    public hotCorners: HotCorner[];
+    public uiGroup: UiActor;
+    public overviewGroup: St.Widget;
+    public screenShieldGroup: St.Widget;
+    public panelBox: St.BoxLayout;
+    public modalDialogGroup: St.Widget;
+    public keyboardBox: St.BoxLayout;
+    public screenshotUIGroup: St.Widget;
+    public dummyCursor: St.Widget;
+    public screenTransition: ScreenTransition;
+    public readonly currentMonitor: Monitor | undefined;
+    public readonly keyboardMonitor: Monitor | undefined;
+    public readonly focusIndex: number;
+    public readonly focusMonitor: Monitor | undefined;
+    public keyboardIndex: number;
+
+    constructor();
+    public _init(): void;
+
+    public init(): void;
+    public showOverview(): void;
+    public hideOverview(): void;
+
+    /**
+     * setDummyCursorGeometry:
+     *
+     * The cursor dummy is a standard widget commonly used for popup
+     * menus and box pointers to track, as the box pointer API only
+     * tracks actors. If you want to pop up a menu based on where the
+     * user clicked, or where the text cursor is, the cursor dummy
+     * is what you should use. Given that the menu should not track
+     * the actual mouse pointer as it moves, you need to call this
+     * function before you show the menu to ensure it is at the right
+     * position and has the right size.
+     * @param x
+     * @param y 
+     * @param width 
+     * @param height 
+     */
+    public setDummyCursorGeometry(x: number, y: number, width: number, height: number): void;
+    
+    /**
+     * Adds `actor` to the chrome, and (unless `affectsInputRegion` in
+     * `params` is `false`) extends the input region to include it.
+     * Changes in `actor`'s size, position, and visibility will
+     * automatically result in appropriate changes to the input
+     * region.
+     *
+     * If `affectsStruts` in `params` is `true` (and `actor` is along a
+     * screen edge), then `actor`'s size and position will also affect
+     * the window manager struts. Changes to `actor`'s visibility will
+     * NOT affect whether or not the strut is present, however.
+     *
+     * If `trackFullscreen` in `params` is `true`, the actor's visibility
+     * will be bound to the presence of fullscreen windows on the same
+     * monitor (it will be hidden whenever a fullscreen window is visible,
+     * and shown otherwise)
+     * @param actor An actor to add to the chrome
+     * @param params Additional params
+     */
+    public addChrome(actor: Clutter.Actor, params?: { affectsStruts?: boolean; affectsInputRegion?: boolean; trackFullscreen?: boolean; }): void;
+
+    /**
+     * Like {@link addChrome()}, but adds `actor` above all windows, including popups.
+     * @param actor An actor to add to the chrome
+     * @param params Additional params
+     */
+    public addTopChrome(actor: Clutter.Actor, params?: { affectsStruts?: boolean; affectsInputRegion?: boolean; trackFullscreen?: boolean; }): void;
+    
+    /**
+     * Tells the chrome to track `actor`. This can be used to extend the
+     * struts or input region to cover specific children.
+     * 
+     * `params` can have any of the same values as in {@link addChrome()},
+     * though some possibilities don't make sense. By default, `actor` has
+     * the same params as its chrome ancestor.
+     * 
+     * @param actor a descendant of the chrome to begin tracking
+     * @param params parameters describing how to track `actor`
+     */
+    public trackChrome(actor: Clutter.Actor, params?: { affectsStruts?: boolean; affectsInputRegion?: boolean; trackFullscreen?: boolean; }): void;
+
+    /**
+     * Undoes the effect of {@link trackChrome()}
+     * `params` is `false`) removes it from the input region.
+     * @param actor An actor previously tracked via {@link trackChrome()}
+     */
+    public untrackChrome(actor: Clutter.Actor): void;
+
+    /**
+     * Removes `actor` from the chrome
+     * @param actor An actor previously added via {@link addChrome()}
+     */
+    public removeChrome(actor: Clutter.Actor): void;
+
+    public getWorkAreaForMonitor(monitorIndex: number) : void
+
+    /**
+     * This call guarantees that we return some monitor to simplify usage of it
+     * In practice all tracked actors should be visible on some monitor anyway
+     * @param actor 
+     */
+    public findIndexForActor(actor: Clutter.Actor): number
+
+    public findMonitorForActor(actor: Clutter.Actor): Monitor | undefined
+
+    public modalEnded(): void;
+
+
+    protected _sessionUpdated(): void;
+    protected _updateMonitors(): void;
+    protected _updateHotCorners(): void;
+    protected _addBackgroundMenu(bgManager: BackgroundManager): void;
+    protected _createBackgroundManager(monitorIndex: number): BackgroundManager;
+    protected _showSecondaryBackgrounds(): void;
+    protected _waitLoaded(bgManager: BackgroundManager): void;
+    protected _updateBackgrounds(): Promise<void>;
+    protected _updateKeyboardBox(): void;
+    protected _updateBoxes(): void;
+    protected _panelBoxChanged(): void;
+    protected _updatePanelBarrier(): void;
+    protected _monitorsChanged(): void;
+    protected _isAboveOrBelowPrimary(monitor: Monitor): boolean;
+    protected _loadBackground(): void;
+    /**
+     * Startup Animations
+     *
+     * We have two different animations, depending on whether we're a greeter
+     * or a normal session.
+     *
+     * In the greeter, we want to animate the panel from the top, and smoothly
+     * fade the login dialog on top of whatever plymouth left on screen which
+     * we get as a still frame background before drawing anything else.
+     *
+     * Here we just have the code to animate the panel, and fade up the background.
+     * The login dialog animation is handled by modalDialog.js
+     *
+     * When starting a normal user session, we want to grow it out of the middle
+     * of the screen.
+     */
+    protected _prepareStartupAnimation(): Promise<void>;
+    protected _startupAnimation(): void;
+    protected _startupAnimationGreeter(): void;
+    protected _startupAnimationSession(): void;
+    protected _startupAnimationComplete(): void;
+    protected _findActor(actor: Clutter.Actor): number;
+    protected _trackActor(actor: Clutter.Actor, params?: { affectsStruts?: boolean; affectsInputRegion?: boolean; trackFullscreen?: boolean; }): void;
+    protected _untrackActor(actor: Clutter.Actor): void;
+    protected _updateActorVisibility(actorData: any): void;
+    protected _updateVisibility(): void;
+    protected _queueUpdateRegions(): void;
+    protected _updateFullscreen(): void;
+    protected _windowsRestacked(): void;
+    protected _updateRegions(): boolean;
+}
+
+declare class PressureBarrier extends EventEmitter {
+
+    protected _threshold: number;
+    protected _timeout: number;
+    protected _actionMode: number;
+    protected _barriers: any[];
+    protected _eventFilter: any | null;
+    protected _isTriggered: boolean;
+    protected _barrierEvents: any[];
+    protected _currentPressure: number;
+    protected _lastTime: number;
+
+    constructor(threshold: number, timeout: number, actionMode: number);
+
+    public addBarrier(barrier: Meta.Barrier): void;
+    public removeBarrier(barrier: Meta.Barrier): void;
+    public destroy(): void;
+    public setEventFilter(filter: any): void;
+
+    protected _disconnectBarrier(barrier: Meta.Barrier): void;
+    protected _reset(): void;
+    protected _isHorizontal(barrier: Meta.Barrier): boolean;
+    protected _getDistanceAcrossBarrier(barrier: Meta.Barrier, event: any): number;
+    protected _getDistanceAlongBarrier(barrier: Meta.Barrier, event: any): number;
+    protected _trimBarrierEvents(): void;
+    protected _onBarrierLeft(barrier: Meta.Barrier, event: any): void;
+    protected _trigger(): void;
+    protected _onBarrierHit(barrier: Meta.Barrier, event: any): void;
+}
+

package/templates/Gjs/ui/layout.js

@@ -0,0 +1,6 @@
+<% if(moduleType === 'esm') { %>
+    export imports.ui.layout;
+<% } else { %>  
+    module.exports = imports.ui.layout;
+<% } %>
+  

package/templates/Gjs/ui/main.d.ts

@@ -0,0 +1,215 @@
+<% const Gio = dep.find('Gio') %>
+
+<%_ if(noNamespace){ _%>
+    import type * as Gio from '../<%= Gio.packageName %>.js';
+<%_ } else { _%>
+    import type Gio from '../<%= Gio.packageName %>.js';
+<%_ } _%>
+
+import { ComponentManager } from './components/__init__.js';
+import { AccessDialogDBus } from './accessDialog.js';
+// const AudioDeviceSelection = imports.ui.audioDeviceSelection;
+// const Components = imports.ui.components;
+// const CtrlAltTab = imports.ui.ctrlAltTab;
+// const EndSessionDialog = imports.ui.endSessionDialog;
+// const ExtensionSystem = imports.ui.extensionSystem;
+// const ExtensionDownloader = imports.ui.extensionDownloader;
+// const InputMethod = imports.misc.inputMethod;
+// const Introspect = imports.misc.introspect;
+// const Keyboard = imports.ui.keyboard;
+// const MessageTray = imports.ui.messageTray;
+// const ModalDialog = imports.ui.modalDialog;
+// const OsdWindow = imports.ui.osdWindow;
+// const OsdMonitorLabeler = imports.ui.osdMonitorLabeler;
+// const Overview = imports.ui.overview;
+// const PadOsd = imports.ui.padOsd;
+import { Panel } from './panel.js';
+// const Params = imports.misc.params;
+// const RunDialog = imports.ui.runDialog;
+// const WelcomeDialog = imports.ui.welcomeDialog;
+import { LayoutManager } from './layout.js';
+// const LoginManager = imports.misc.loginManager;
+// const LookingGlass = imports.ui.lookingGlass;
+import { NotificationDaemon } from './notificationDaemon.js';
+// const WindowAttentionHandler = imports.ui.windowAttentionHandler;
+// const Screenshot = imports.ui.screenshot;
+// const ScreenShield = imports.ui.screenShield;
+// const Scripting = imports.ui.scripting;
+// const SessionMode = imports.ui.sessionMode;
+// const ShellDBus = imports.ui.shellDBus;
+// const ShellMountOperation = imports.ui.shellMountOperation;
+// const WindowManager = imports.ui.windowManager;
+// const Magnifier = imports.ui.magnifier;
+// const XdndHandler = imports.ui.xdndHandler;
+// const KbdA11yDialog = imports.ui.kbdA11yDialog;
+// const LocatePointer = imports.ui.locatePointer;
+// const PointerA11yTimeout = imports.ui.pointerA11yTimeout;
+// const ParentalControlsManager = imports.misc.parentalControlsManager;
+// const Config = imports.misc.config;
+// const Util = imports.misc.util;
+
+export declare const componentManager: ComponentManager;
+
+export declare const panel: Panel;
+
+export declare const notificationDaemon: NotificationDaemon;
+
+export declare const windowAttentionHandler: any;
+
+export declare const ctrlAltTabManager: any;
+
+export declare const padOsdService: any;
+
+export declare const osdWindowManager: any;
+
+export declare const osdMonitorLabeler: any;
+
+export declare const shellMountOpDBusService: any;
+
+export declare const shellDBusService: any;
+
+export declare const shellAccessDialogDBusService: AccessDialogDBus;
+
+export declare const shellAudioSelectionDBusService: any;
+
+export declare const screenSaverDBus: any;
+
+export declare const uiGroup: any;
+
+export declare const magnifier: any;
+
+export declare const xdndHandler: any;
+
+export declare const keyboard: any;
+
+export declare const layoutManager: LayoutManager;
+
+export declare const kbdA11yDialog: any;
+
+export declare const inputMethod: any;
+
+export declare const introspectService: any;
+
+export declare const locatePointer: any;
+
+/**
+ * pushModal:
+ * @param actor: actor which will be given keyboard focus
+ * @param params: optional parameters
+ *
+ * Ensure we are in a mode where all keyboard and mouse input goes to
+ * the stage, and focus @actor. Multiple calls to this function act in
+ * a stacking fashion; the effect will be undone when an equal number
+ * of popModal() invocations have been made.
+ *
+ * Next, record the current Clutter keyboard focus on a stack. If the
+ * modal stack returns to this actor, reset the focus to the actor
+ * which was focused at the time pushModal() was invoked.
+ *
+ * @params may be used to provide the following parameters:
+ *  - timestamp: used to associate the call with a specific user initiated
+ *               event. If not provided then the value of
+ *               global.get_current_time() is assumed.
+ *
+ *  - options: Meta.ModalOptions flags to indicate that the pointer is
+ *             already grabbed
+ *
+ *  - actionMode: used to set the current Shell.ActionMode to filter
+ *                global keybindings; the default of NONE will filter
+ *                out all keybindings
+ *
+ * @returns The grab handle created
+ */
+export function pushModal(actor: any /* Clutter.Actor */, params?: any): any /* Clutter.Grab */;
+
+/**
+ * popModal:
+ * @param grab - the grab given by pushModal()
+ * @param timestamp - optional timestamp
+ *
+ * Reverse the effect of pushModal(). If this invocation is undoing
+ * the topmost invocation, then the focus will be restored to the
+ * previous focus at the time when pushModal() was invoked.
+ *
+ * @timestamp is optionally used to associate the call with a specific user
+ * initiated event. If not provided then the value of
+ * global.get_current_time() is assumed.
+ */
+
+export function popModal(grab: any /* Clutter.Grab */, timestamp?: number): void;
+
+/**
+ * activateWindow:
+ * @param {Meta.Window} window: the window to activate
+ * @param {number=} time: current event time
+ * @param {number=} workspaceNum:  window's workspace number
+ *
+ * Activates @window, switching to its workspace first if necessary,
+ * and switching out of the overview if it's currently active
+ */
+export function activateWindow(window: any /* Meta.Window */, time?: number, workspaceNum?: number): void;
+
+/**
+ * Move @window to the specified monitor and workspace.
+ *
+ * @param window - the window to move
+ * @param monitorIndex - the requested monitor
+ * @param workspaceIndex - the requested workspace
+ * @param append - create workspace if it doesn't exist
+ */
+export function moveWindowToMonitorAndWorkspace(window: any /* Meta.Window */, monitorIndex: number, workspaceIndex: number, append: boolean): void;
+
+export declare const createLookingGlass: any;
+
+export declare const initializeDeferredWork: any;
+
+/**
+ * loadTheme:
+ *
+ * Reloads the theme CSS file
+ */
+
+export function loadTheme(): void;
+
+/**
+ * notify:
+ * @param msg: A message
+ * @param details: Additional information
+ */
+
+export function notify(msg: string, details?: string): void;
+
+/**
+ * notifyError:
+ * @param msg: An error message
+ * @param details: Additional information
+ *
+ * See shell_global_notify_problem().
+ */
+
+export function notifyError(msg: string, details?: string): void;
+
+export function start(): void;
+
+/**
+ * getThemeStylesheet:
+ *
+ * Get the theme CSS file that the shell will load
+ *
+ * @returns A #GFile that contains the theme CSS,
+ *          null if using the default
+ */
+
+export function getThemeStylesheet(): Gio.File | null;
+
+/**
+ * setThemeStylesheet:
+ * @param {string=} cssStylesheet: A file path that contains the theme CSS,
+ *     set it to null to use the default
+ *
+ * Set the theme CSS file that the shell will load
+ */
+
+export function setThemeStylesheet(cssStylesheet: string): void;
+
+export declare const screenshotUI: any;

package/templates/Gjs/ui/main.js

@@ -0,0 +1,6 @@
+<% if(moduleType === 'esm') { %>
+    export imports.ui.main;
+<% } else { %>  
+    module.exports = imports.ui.main;
+<% } %>
+  

package/templates/Gjs/ui/messageList.d.ts

@@ -0,0 +1,113 @@
+// https://gitlab.gnome.org/GNOME/gnome-shell/-/blob/main/js/ui/messageList.js
+
+<% const St = dep.find('St') %>
+<% const Clutter = dep.find('Clutter') %>
+
+<%_ if(noNamespace){ _%>
+    import type * as St from '../<%= St.packageName %>.js';
+    import type * as Clutter from '../<%= Clutter.packageName %>.js';
+<%_ } else { _%>
+    import type St from '../<%= St.packageName %>.js';
+    import type Clutter from '../<%= Clutter.packageName %>.js';
+<%_ } _%>
+
+declare function _fixMarkup(text: string, allowMarkup?: boolean): string;
+
+declare class URLHighlighter extends St.Label {
+
+    constructor(text?: string, lineWrap?: boolean, allowMarkup?: boolean);
+
+    /** @hidden */
+    public _init(params?: St.Label.ConstructorProperties): void;
+    public _init(text?: string, lineWrap?: boolean, allowMarkup?: boolean): void;
+
+    public vfunc_button_press_event(buttonEvent: Clutter.ButtonEvent): boolean;
+    public vfunc_button_release_event(buttonEvent: Clutter.ButtonEvent): boolean;
+    public vfunc_motion_event(motionEvent: Clutter.MotionEvent): boolean;
+    public vfunc_leave_event(crossingEvent: Clutter.CrossingEvent): boolean;
+    public setMarkup(text: string, allowMarkup?: boolean): void;
+
+    protected _highlightUrls(): void;
+    protected _findUrlAtPos(event: Clutter.Event): [number, number];
+}
+
+declare class ScaleLayout extends Clutter.BinLayout {
+    constructor(params?: Clutter.BinLayout.ConstructorProperties);
+    public _init(params?: Clutter.BinLayout.ConstructorProperties): void;
+
+    public vfunc_get_preferred_width(container: Clutter.Container, forHeight: number): [number, number];
+    public vfunc_get_preferred_height(container: Clutter.Container, forWidth: number): [number, number];
+
+    protected _connectContainer(container: Clutter.Container): void;
+}
+
+declare class LabelExpanderLayout extends Clutter.LayoutManager {
+
+    protected _expansion: number;
+    protected _expandLines: number;
+    protected _container: Clutter.Container;
+
+    public expansion: number;
+    public readonly expandLines: number;
+
+
+    constructor(params?: Clutter.LayoutManager.ConstructorProperties)
+    _init(params?: Clutter.LayoutManager.ConstructorProperties): void;
+
+    vfunc_set_container(container: Clutter.Container): void;
+    vfunc_get_preferred_width(container: Clutter.Container, forHeight: number): [number, number];
+    vfunc_get_preferred_height(container: Clutter.Container, forWidth: number): [number, number];
+    vfunc_allocate(container: Clutter.Container, box: Clutter.ActorBox): void;
+}
+
+export class Message extends St.Button {
+    constructor(title: string, body: string);
+    /** @hidden */
+    public _init(params?: St.Button.ConstructorProperties): void;
+    public _init(title: string, body: string): void;
+
+    public close(): void;
+    public setIcon(actor: St.Widget): void;
+    public setSecondaryActor(actor: St.Widget): void;
+    public setTitle(text: string): void;
+    public setBody(text: string): void;
+    public setUseBodyMarkup(enable: boolean): void;
+    public setActionArea(actor: St.Widget): void;
+    public addMediaControl(iconName: string, callback: () => void): void;
+    public setExpandedBody(actor: St.Widget): void;
+    public setExpandedLines(nLines: number): void;
+    public expand(animate?: boolean): void;
+    public unexpand(animate?: boolean): void;
+    public canClose(): boolean;
+    public vfunc_key_press_event(keyEvent: Clutter.KeyEvent): boolean;
+
+    protected _sync(): void;
+    protected _onDestroy(): void;
+}
+
+export class MessageListSection extends St.BoxLayout {
+
+    protected _list: St.BoxLayout;
+    protected _empty: boolean;
+    protected _canClear: boolean;
+    protected readonly _messages: St.Widget[];
+
+    public readonly empty: boolean;
+    public readonly canClear: boolean;
+    public readonly allowed: boolean;
+
+    constructor();
+    /** @hidden */
+    public _init(params?: St.BoxLayout.ConstructorProperties): void;
+    public _init(): void;
+
+    public addMessage(message: Message, animate?: boolean): void;
+    public addMessageAtIndex(message: Message, index: number, animate?: boolean): void;
+    public moveMessage(message: Message, newIndex: number, animate?: boolean): void;
+    public removeMessage(message: Message, animate?: boolean): void;
+    public clear(): void;
+
+    protected _onKeyFocusIn(messageActor: St.Widget): void;
+    protected _shouldShow(): boolean;
+    protected _sync(): void;
+}

package/templates/Gjs/ui/messageList.js

@@ -0,0 +1,6 @@
+<% if(moduleType === 'esm') { %>
+    export imports.ui.messageList;
+<% } else { %>  
+    module.exports = imports.ui.messageList;
+<% } %>
+