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

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

@@ -0,0 +1,204 @@
+// https://gitlab.gnome.org/GNOME/gnome-shell/-/blob/main/js/ui/appDisplay.js
+
+<% const Gio = dep.find('Gio') %>
+<% const St = dep.find('St') %>
+<% const Clutter = dep.find('Clutter') %>
+
+<%_ if(noNamespace){ _%>
+    import type * as Gio from '../<%= Gio.packageName %>.js';
+    import type * as St from '../<%= St.packageName %>.js';
+    import type * as Clutter from '../<%= Clutter.packageName %>.js';
+<%_ } else { _%>
+    import type Gio from '../<%= Gio.packageName %>.js';
+    import type St from '../<%= St.packageName %>.js';
+    import type Clutter from '../<%= Clutter.packageName %>.js';
+<%_ } _%>
+
+import { GridSearchResult } from './search.js';
+
+import { IconGrid, BaseIcon } from './iconGrid.js';
+import { DragMotionResult } from './dnd.js';
+
+export class AppGrid extends IconGrid {
+
+    public indicatorsPadding: number;
+
+    /** @hidden */
+    public _init(params?: St.Viewport.ConstructorProperties): void;
+    public _init(layoutParams?: IconGrid.ConstructorProperties): void;
+
+    protected _updatePadding(): void;
+
+}
+
+export abstract class BaseAppView extends St.Widget {
+    // TODO: 'view-loaded' signal
+    constructor(params?: St.Widget.ConstructorProperties);
+    public _init(params?: St.Widget.ConstructorProperties): void;
+
+    protected _onDestroy(): void;
+    protected _createGrid(): AppGrid;
+    protected _onScroll(actor: St.Widget, event: Clutter.ScrollEvent): boolean;
+    protected _swipeBegin(tracker: any, monitor: Clutter.EventSequence): void;
+    protected _swipeUpdate(tracker: any, progress: number): void;
+    protected _swipeEnd(tracker: any, duration: number, endProgress: number): void;
+    protected _connectDnD(): void;
+    protected _disconnectDnD(): void
+    protected _maybeMoveItem(dragEvent: Clutter.Event): void;
+    protected _removeDelayedMove(): void;
+    protected _resetDragPageSwitch(): void;
+    protected _setupDragPageSwitchRepeat(direction: number): void;
+    protected _dragMaybeSwitchPageImmediately(dragEvent: Clutter.Event): void;
+    protected _maybeSetupDragPageSwitchInitialTimeout(dragEvent: Clutter.Event): void;
+    protected _onDragBegin(): void;
+    protected _onDragMotion(dragEvent: Clutter.Event): boolean;
+    protected _onDragDrop(dropEvent: Clutter.Event): boolean;
+    protected _onDragEnd(): void;
+    protected _onDragCancelled(): void;
+    protected _canAccept(source: any): boolean;
+    protected _findBestPageToAppend(startPage?: number): number;
+    protected _getLinearPosition(page: number, position: number): number;
+    protected _addItem(item: any, page: number, position: number): void;
+    protected _removeItem(item: any): void;
+    protected _redisplay(): void;
+    protected _compareItems(a: any, b: any): number;
+    protected _selectAppInternal(id: string): void;
+    protected _getDropTarget(x: number, y: number, source: any): [number, number, number];
+    protected _moveItem(item: any, newPage: number, newPosition: number): void;
+
+    public handleDragOver(source: any): DragMotionResult;
+    public acceptDrop(source: any): boolean;
+    public getItemPosition(item: any): [number, number];
+    public getAllItems(): any[];
+    public selectApp(id: string): void;
+    public animateSwitch(animationDirection: number): void;
+    public goToPage(pageNumber: number, animate: boolean): void;
+    public updateDragFocus(dragFocus: any): void;
+}
+
+export class AppDisplay extends BaseAppView {
+    constructor();
+    public _init(): void;
+
+    protected _onDestroy(): void;
+    protected _redisplay(): void;
+    protected _savePages(): void;
+    protected _ensureDefaultFolders(): void;
+    protected _ensurePlaceholder(source: any): void;
+    protected _removePlaceholder(): void;
+    protected _getItemPosition(item: any): [number, number];
+    protected _compareItems(a: any, b: any): number;
+    protected _loadApps(): void;
+    protected _onScroll(actor: St.Widget, event: Clutter.ScrollEvent): boolean;
+    protected _onKeyPressEvent(actor: St.Widget, event: Clutter.KeyEvent): boolean;
+    protected _maybeMoveItem(dragEvent: Clutter.Event): void;
+    /** @hidden */
+    protected _onDragBegin(): void;
+    protected _onDragBegin(overview: any, source: any): void;
+    protected _onDragMotion(dragEvent: Clutter.Event): boolean;
+    protected _onDragEnd(): void;
+    /** @hidden */
+    protected _onDragCancelled(): void;
+    protected _onDragCancelled(overview: any, source: any): void;
+
+    public getAppInfos(): any[];
+    public animateSwitch(animationDirection: number): void;
+    public goToPage(pageNumber: number, animate?: boolean): void;
+    public addFolderDialog(dialog: any): void;
+    public acceptDrop(source: any): boolean;
+    public createFolder(apps: any[]): boolean;
+}
+
+export class AppSearchProvider {
+    constructor();
+
+    public getResultMetas(apps: any[]): Promise<any[]>;
+    public filterResults(results: any[], maxNumber: number): any[];
+    public getInitialResultSet(terms: string[], cancellable: Gio.Cancellable): Promise<any[]>;
+    public getSubsearchResultSet(previousResults: any[], terms: string[], cancellable: Gio.Cancellable): any[];
+    public createResultObject(resultMeta: any): AppIcon | SystemActionIcon;
+}
+
+export class AppViewItem extends St.Button {
+
+    readonly id: string;
+    readonly app: any;
+
+    constructor(params?: St.Button.ConstructorProperties);
+    public _init(params?: St.Button.ConstructorProperties, isDraggable?: boolean, expandTitleOnHover?: boolean): void;
+
+    protected _onDestroy(): void;
+    protected _updateMultiline(): void;
+    protected _onHover(): void;
+    protected _onDragBegin(): void;
+    protected _onDragCancelled(): void;
+    protected _onDragEnd(): void;
+    protected _canAccept(source: any): boolean;
+    protected _setHoveringByDnd(hovering: boolean): void;
+    protected _onDragMotion(dragEvent: Clutter.Event): boolean;
+    protected _withinLeeways(x: number): boolean;
+
+    public scaleIn(): void;
+    public scaleAndFade(): void;
+    public undoScaleAndFade(): void;
+    public handleDragOver(source: any, actor: St.Widget, x: number): DragMotionResult;
+    public acceptDrop(source: any, actor: St.Widget, x: number): boolean;
+    public cancelActions(): void;
+    public setForcedHighlight(highlight: boolean): void;
+}
+
+export namespace AppIcon {
+    export interface ConstructorProperties extends BaseIcon.ConstructorProperties {
+        isDraggable?: boolean;
+        expandTitleOnHover?: boolean;
+    }
+}
+
+export class AppIcon extends AppViewItem {
+
+    public app: any;
+    public icon: BaseIcon;
+
+    protected _id: string;
+    protected _name: string;
+    protected _iconContainer: St.Widget;
+    protected _folderPreviewId: number;
+
+    constructor(app: any, iconParams?: AppIcon.ConstructorProperties);
+
+    /** @hidden */
+    public _init(params?: St.Button.ConstructorProperties, isDraggable?: boolean, expandTitleOnHover?: boolean): void;
+    public _init(app: any, iconParams?: AppIcon.ConstructorProperties): void;
+
+    protected _onDestroy(): void;
+    protected _createIcon(iconSize: number): St.Widget;
+    protected _removeMenuTimeout(): void;
+    protected _setPopupTimeout(): void;
+    protected _onKeyboardPopupMenu(): void;
+    protected _onMenuPoppedDown(): void;
+    protected _onMenuPoppedDown(button: St.Button): void;
+    protected _showFolderPreview(): void;
+    protected _hideFolderPreview(): void;
+    protected _canAccept(source: any): boolean;
+    protected _setHoveringByDnd(hovering: boolean): void;
+
+    public onDragBegin(): void;
+    public updateRunningStyle(): void;
+    public getId(): string;
+    public popupMenu(side?: St.Side): void;
+    public animateLaunch(): void;
+    public animateLaunchAtPos(x: number, y: number): void;
+    public shellWorkspaceLaunch(params?: { workspace: number; timestamp: number }): void;
+    public getDragActor(): St.Widget;
+    /**
+     * @returns The original actor that should align with the actor we show as the item is being dragged.
+     */
+    public getDragActorSource(): St.Widget;
+    public shouldShowTooltip(): boolean;
+    public acceptDrop(source: any, actor: St.Widget, x: number): boolean;
+    public cancelActions(): void;
+}
+
+export class SystemActionIcon extends GridSearchResult {
+    activate(): void;
+}

package/templates/Gjs/ui/appDisplay.js

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

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

@@ -0,0 +1,34 @@
+// https://gitlab.gnome.org/GNOME/gnome-shell/-/blob/main/js/ui/appFavorites.js
+
+<% const Shell = dep.find('Shell') %>
+
+<%_ if(noNamespace){ _%>
+    import type * as Shell from '../<%= Shell.packageName %>.js';
+<%_ } else { _%>
+    import type Shell from '../<%= Shell.packageName %>.js';
+<%_ } _%>
+
+import { EventEmitter } from '../misc/signals.js';
+
+declare class AppFavorites extends EventEmitter {
+
+    protected _favorites: Map<string, Shell.App>;
+
+    constructor();
+
+    protected _onFavsChanged(): void;
+    protected _getIds(): string[];
+    protected _addFavorite(appId: string, pos: number): void;
+    protected _removeFavorite(appId: string): void;
+
+    public reload(): void;
+    public getFavoriteMap(): Map<string, Shell.App>;
+    public getFavorites(): Shell.App[];
+    public isFavorite(appId: string): boolean;
+    public addFavoriteAtPos(appId: string, pos: number): void;
+    public addFavorite(appId: string): void;
+    public moveFavoriteToPos(appId: string, pos: number): void;
+    public removeFavorite(appId: string): void;
+}
+
+export function getAppFavorites(): AppFavorites;

package/templates/Gjs/ui/appFavorites.js

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

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

@@ -0,0 +1,74 @@
+// https://gitlab.gnome.org/GNOME/gnome-shell/-/blob/main/js/ui/appMenu.js
+
+<% const St = dep.find('St') %>
+<% const Clutter = dep.find('Clutter') %>
+<% const Shell = dep.find('Shell') %>
+
+<%_ if(noNamespace){ _%>
+    import type * as St from '../<%= St.packageName %>.js';
+    import type * as Clutter from '../<%= Clutter.packageName %>.js';
+    import type * as Shell from '../<%= Shell.packageName %>.js';
+<%_ } else { _%>
+    import type St from '../<%= St.packageName %>.js';
+    import type Clutter from '../<%= Clutter.packageName %>.js';
+    import type Shell from '../<%= Shell.packageName %>.js';
+<%_ } _%>
+
+
+import type { PopupMenu, PopupSeparatorMenuItem, PopupMenuSection } from './popupMenu.js';
+import type { getAppFavorites } from './appFavorites.js';
+import type { getDefault } from '../misc/parentalControlsManager.js';
+
+export class AppMenu extends PopupMenu {
+
+    protected _app: Shell.App | null;
+    protected _appSystem: Shell.AppSystem;
+    protected _parentalControlsManager: ReturnType<typeof getDefault>;
+    protected _appFavorites: ReturnType<typeof getAppFavorites>;
+    protected _enableFavorites: boolean;
+    protected _showSingleWindows: boolean;
+
+    protected _windowsChangedId: number;
+    protected _updateWindowsLaterId: number;
+
+    protected _openWindowsHeader: PopupSeparatorMenuItem;
+    protected _windowSection: PopupMenuSection;
+    protected _newWindowItem: ReturnType<typeof this.addAction>;
+    protected _actionSection: PopupMenuSection;
+    protected _onGpuMenuItem: ReturnType<typeof this.addAction>;
+    protected _detailsItem: ReturnType<typeof this.addAction>;
+    protected _quitItem: ReturnType<typeof this.addAction>;
+
+    /**
+     * @param sourceActor - actor the menu is attached to
+     * @param side - arrow side
+     * @param params - options
+     * @param params.favoritesSection - show items to add/remove favorite
+     * @param params.showSingleWindow - show window section for a single window
+     */
+    constructor(sourceActor: Clutter.Actor, side?: St.Side, params?: { favoritesSection?: boolean; showSingleWindow: boolean; })
+
+    protected _onAppStateChanged(sys: any, app: any): void;
+    protected _updateQuitItem(): void;
+    protected _updateNewWindowItem(): void;
+    protected _updateFavoriteItem(): void;
+    protected _updateGpuItem(): void;
+    protected _updateDetailsVisibility(): void;
+    protected _animateLaunch(): void;
+    protected _getNonDefaultLaunchGpu(): Shell.AppLaunchGpu;
+    protected _queueUpdateWindowsSection(): void;
+    protected _updateWindowsSection(): void;
+
+
+    public destroy(): void;
+
+    /**
+     * @returns true if the menu is empty
+     */
+    public isEmpty(): boolean;
+
+    /**
+     * @param app the app the menu represents
+     */
+    public setApp(app: Shell.App): void;
+}

package/templates/Gjs/ui/appMenu.js

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

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

@@ -0,0 +1,51 @@
+// https://gitlab.gnome.org/GNOME/gnome-shell/-/blob/main/js/ui/audioDeviceSelection.js
+
+<% const Gio = dep.find('Gio') %>
+<% const St = dep.find('St') %>
+
+<%_ if(noNamespace){ _%>
+    import type * as Gio from '../<%= Gio.packageName %>.js';
+    import type * as St from '../<%= St.packageName %>.js';
+<%_ } else { _%>
+    import type Gio from '../<%= Gio.packageName %>.js';
+    import type St from '../<%= St.packageName %>.js';
+<%_ } _%>
+
+import type { ModalDialog } from './modalDialog.js';
+
+export enum AudioDevice {
+    HEADPHONES = 1 << 0,
+    HEADSET =    1 << 1,
+    MICROPHONE = 1 << 2,
+}
+
+declare class AudioDeviceSelectionDialog extends ModalDialog {
+
+    constructor(devices: number);
+
+    /** @hidden */
+    public _init(params?: St.Widget.ConstructorProperties): void;
+    /** @hidden */
+    public _init(props?: ModalDialog.ConstructorProperties): void;
+    public _init(devices: number): void;
+
+
+    protected _buildLayout(): void;
+    protected _getDeviceLabel(device: AudioDevice): string | null;
+    protected _getDeviceIcon(device: AudioDevice): string | null;
+    protected _addDevice(device: AudioDevice): void;
+    protected _openSettings(): void;
+}
+
+export class AudioDeviceSelectionDBus {
+    protected _audioSelectionDialog: AudioDeviceSelectionDialog | null;
+    protected _dbusImpl: Gio.DBusExportedObject;
+
+    constructor();
+
+    protected _onDialogClosed(): void;
+    protected _onDeviceSelected(dialog: AudioDeviceSelectionDialog, device: AudioDevice): void;
+
+    OpenAsync(params: string[], invocation: Gio.DBusMethodInvocation): void;
+    CloseAsync(params: any, invocation: Gio.DBusMethodInvocation): void;
+}

package/templates/Gjs/ui/audioDeviceSelection.js

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

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

@@ -0,0 +1,255 @@
+/**
+ * READ THIS FIRST
+ * Background handling is a maze of objects, both objects in this file, and
+ * also objects inside Mutter. They all have a role.
+ *
+ * BackgroundManager
+ *   The only object that other parts of GNOME Shell deal with; a
+ *   BackgroundManager creates background actors and adds them to
+ *   the specified container. When the background is changed by the
+ *   user it will fade out the old actor and fade in the new actor.
+ *   (This is separate from the fading for an animated background,
+ *   since using two actors is quite inefficient.)
+ *
+ * MetaBackgroundImage
+ *   An object represented an image file that will be used for drawing
+ *   the background. MetaBackgroundImage objects asynchronously load,
+ *   so they are first created in an unloaded state, then later emit
+ *   a ::loaded signal when the Cogl object becomes available.
+ *
+ * MetaBackgroundImageCache
+ *   A cache from filename to MetaBackgroundImage.
+ *
+ * BackgroundSource
+ *   An object that is created for each GSettings schema (separate
+ *   settings schemas are used for the lock screen and main background),
+ *   and holds a reference to shared Background objects.
+ *
+ * MetaBackground
+ *   Holds the specification of a background - a background color
+ *   or gradient and one or two images blended together.
+ *
+ * Background
+ *   JS delegate object that Connects a MetaBackground to the GSettings
+ *   schema for the background.
+ *
+ * Animation
+ *   A helper object that handles loading a XML-based animation; it is a
+ *   wrapper for GnomeDesktop.BGSlideShow
+ *
+ * MetaBackgroundActor
+ *   An actor that draws the background for a single monitor
+ *
+ * BackgroundCache
+ *   A cache of Settings schema => BackgroundSource and of a single Animation.
+ *   Also used to share file monitors.
+ *
+ * A static image, background color or gradient is relatively straightforward. The
+ * calling code creates a separate BackgroundManager for each monitor. Since they
+ * are created for the same GSettings schema, they will use the same BackgroundSource
+ * object, which provides a single Background and correspondingly a single
+ * MetaBackground object.
+ *
+ * BackgroundManager               BackgroundManager
+ *        |        \               /        |
+ *        |         BackgroundSource        |        looked up in BackgroundCache
+ *        |                |                |
+ *        |            Background           |
+ *        |                |                |
+ *   MetaBackgroundActor   |    MetaBackgroundActor
+ *         \               |               /
+ *          `------- MetaBackground ------'
+ *                         |
+ *                MetaBackgroundImage            looked up in MetaBackgroundImageCache
+ *
+ * The animated case is tricker because the animation XML file can specify different
+ * files for different monitor resolutions and aspect ratios. For this reason,
+ * the BackgroundSource provides different Background share a single Animation object,
+ * which tracks the animation, but use different MetaBackground objects. In the
+ * common case, the different MetaBackground objects will be created for the
+ * same filename and look up the *same* MetaBackgroundImage object, so there is
+ * little wasted memory:
+ *
+ * BackgroundManager               BackgroundManager
+ *        |        \               /        |
+ *        |         BackgroundSource        |        looked up in BackgroundCache
+ *        |             /      \            |
+ *        |     Background   Background     |
+ *        |       |     \      /   |        |
+ *        |       |    Animation   |        |        looked up in BackgroundCache
+ * MetaBackgroundA|tor           Me|aBackgroundActor
+ *         \      |                |       /
+ *      MetaBackground           MetaBackground
+ *                 \                 /
+ *                MetaBackgroundImage            looked up in MetaBackgroundImageCache
+ *                MetaBackgroundImage
+ *
+ * But the case of different filenames and different background images
+ * is possible as well:
+ *                        ....
+ *      MetaBackground              MetaBackground
+ *             |                          |
+ *     MetaBackgroundImage         MetaBackgroundImage
+ *     MetaBackgroundImage         MetaBackgroundImage
+ * @see https://gitlab.gnome.org/GNOME/gnome-shell/-/blob/main/js/ui/background.js
+ */
+
+<% const Gio = dep.find('Gio') %>
+<% const Clutter = dep.find('Clutter') %>
+<% const Meta = dep.find('Meta') %>
+<% const GnomeDesktop = dep.find('GnomeDesktop') %>
+
+<%_ if(noNamespace){ _%>
+    import type * as Gio from '../<%= Gio.packageName %>.js';
+    import type * as Clutter from '../<%= Clutter.packageName %>.js';
+    import type * as Meta from '../<%= Meta.packageName %>.js';
+    import type * as GnomeDesktop from '../<%= GnomeDesktop.packageName %>.js';
+<%_ } else { _%>
+    import type Gio from '../<%= Gio.packageName %>.js';
+    import type Clutter from '../<%= Clutter.packageName %>.js';
+    import type Meta from '../<%= Meta.packageName %>.js';
+    import type GnomeDesktop from '../<%= GnomeDesktop.packageName %>.js';
+<%_ } _%>
+
+import { EventEmitter } from '../misc/signals.js';
+
+import type { LayoutManager, Monitor } from './layout.js';
+
+/**
+ * A cache of Settings schema => BackgroundSource and of a single Animation.
+ * Also used to share file monitors.
+ */
+declare class BackgroundCache extends EventEmitter {
+
+    protected _backgroundSources: Map<string, BackgroundSource>;
+    protected _fileMonitors: Map<string, Gio.FileMonitor>;
+    protected _animations: Map<string, Animation>;
+
+    constructor();
+
+    public monitorFile(file: Gio.File): Gio.FileMonitor
+    public getAnimation(params?: { file?: Gio.File | null; settingsSchema?: Gio.SettingsSchema | null; onLoaded: (animation: Animation) => void; }): void
+    public getBackgroundSource(layoutManager: LayoutManager, settingsSchema: Gio.SettingsSchema): BackgroundSource
+    public releaseBackgroundSource(settingsSchema: Gio.SettingsSchema): void
+}
+
+/**
+ * JS delegate object that Connects a MetaBackground to the GSettings
+ * schema for the background.
+ */
+declare class Background extends Meta.Background {
+
+    protected _settings: Gio.Settings | null;
+    protected _file: Gio.File | null;
+    protected _style: string | null;
+    protected _monitorIndex: number;
+    protected _layoutManager: LayoutManager;
+    protected _fileWatches: Map<string, Gio.FileMonitor>;
+    protected _cancellable: Gio.Cancellable;
+    protected _interfaceSettings: Gio.Settings;
+    protected _clock: GnomeDesktop.WallClock;
+
+    public isLoaded: boolean;
+
+    constructor(params?: { monitorIndex?: number; layoutManager: LayoutManager; settings?: Gio.Settings | null; file: Gio.File | null; style: string | null; })
+
+    /** @hidden */
+    public _init(params?: Meta.Background.ConstructorProperties): void
+    public _init(params?: { monitorIndex?: number; layoutManager: LayoutManager; settings?: Gio.Settings | null; file: Gio.File | null; style: string | null; }): void
+
+    public destroy(): void
+    public updateResolution(): void
+
+    protected _emitChangedSignal(): void
+    protected _refreshAnimation(): void
+    protected _setLoaded(): void
+    protected _loadPattern(): void
+    protected _watchFile(file: Gio.File): void
+    protected _removeAnimationTimeout(): void
+    protected _updateAnimation(): void
+    protected _queueUpdateAnimation(): void
+    protected _loadAnimation(file: Gio.File): void
+    protected _loadImage(file: Gio.File): void
+    protected _loadFile(file: Gio.File): Promise<void>
+    protected _load(): void
+}
+
+export class SystemBackground extends Meta.BackgroundActor {
+
+    constructor();
+
+    /** @hidden */
+    public _init(params?: Meta.BackgroundActor.ConstructorProperties): void
+    public _init(): void
+}
+
+/**
+ * An object that is created for each GSettings schema (separate
+ * settings schemas are used for the lock screen and main background),
+ * and holds a reference to shared Background objects.
+ */
+declare class BackgroundSource {
+
+    protected _layoutManager: LayoutManager;
+    protected _overrideImage: string | null;
+    protected _settings: Gio.Settings;
+    protected _backgrounds: Background[];
+    protected _monitorsChangedId: number;
+    protected _interfaceSettings: Gio.Settings;
+
+    constructor(layoutManager: LayoutManager, settingsSchema: Gio.SettingsSchema);
+
+    public getBackground(monitorIndex: number): Background
+    public destroy(): void
+
+    protected _onMonitorsChanged(): void
+}
+
+/**
+ * A helper object that handles loading a XML-based animation; it is a
+ * wrapper for GnomeDesktop.BGSlideShow
+ */
+declare class Animation extends GnomeDesktop.BGSlideShow {
+
+    public _init(params?: GnomeDesktop.BGSlideShow.ConstructorProperties): void
+
+    /** @hidden */
+    load_async(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void
+    /**
+     * Tries to load the slide show asynchronously.
+     * @param cancellable a #GCancellable
+     * @param callback the callback
+     */
+    load_async(cancellable: Gio.Cancellable | null, callback?: () => void): void
+    update(monitor: Monitor): void
+}
+
+/**
+ * The only object that other parts of GNOME Shell deal with; a
+ * BackgroundManager creates background actors and adds them to
+ * the specified container. When the background is changed by the
+ * user it will fade out the old actor and fade in the new actor.
+ * (This is separate from the fading for an animated background,
+ * since using two actors is quite inefficient.)
+ */
+export class BackgroundManager extends EventEmitter {
+    protected _settingsSchema: Gio.SettingsSchema;
+    protected _backgroundSource: BackgroundSource;
+    protected _container: Clutter.Actor | null;
+    protected _layoutManager: LayoutManager;
+    protected _vignette: boolean;
+    protected _monitorIndex: number | null;
+    protected _controlPosition: boolean;
+    protected _useContentSize: boolean;
+    protected _newBackgroundActor: Meta.BackgroundActor;
+
+    public backgroundActor: Meta.BackgroundActor;
+
+    constructor(params: { container?: Clutter.Actor | null; layoutManager?: LayoutManager; monitorIndex?: number | null; vignette?: boolean; controlPosition?: boolean; settingsSchema?: Gio.SettingsSchema; useContentSize?: boolean; });
+
+    public destroy(): void
+
+    protected _swapBackgroundActor(): void
+    protected _updateBackgroundActor(): void
+    protected _createBackgroundActor(): Meta.BackgroundActor
+}

package/templates/Gjs/ui/background.js

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

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

@@ -0,0 +1,19 @@
+// https://gitlab.gnome.org/GNOME/gnome-shell/-/blob/main/js/ui/backgroundMenu.js
+
+<% const Clutter = dep.find('Clutter') %>
+
+<%_ if(noNamespace){ _%>
+    import type * as Clutter from '../<%= Clutter.packageName %>.js';
+<%_ } else { _%>
+    import type Clutter from '../<%= Clutter.packageName %>.js';
+<%_ } _%>
+
+
+import type { PopupMenu } from './popupMenu.js';
+import type { LayoutManager } from './layout.js';
+
+declare class BackgroundMenu extends PopupMenu {
+    constructor(layoutManager: LayoutManager);
+}
+
+export function addBackgroundMenu(actor: Clutter.Actor, layoutManager: LayoutManager): BackgroundMenu;

package/templates/Gjs/ui/backgroundMenu.js

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